Apparatus for predicting overlapped storage operands for move character

ABSTRACT

An apparatus is presented and proved for detecting storage operand overlap for instructions having identical overlap detection requirements as the move character (MVC) instruction. The apparatus is applicable to all Enterprise Systems Architecture (ESA)/390 addressing modes encompassing access register addressing for either 24 bit or 31 bit addressing. S/370 addressing in 24 bit and 31 bit modes are also supported by the proposed apparatus and treated as special cases of access register addressing. In addition, the apparatus is extended to support other addressing modes with an example provided to include a 64 bit addressing mode. A fast parallel implementation of the apparatus is also presented. The apparatus results in a one cycle savings for all invocations of the MVC instruction which comprises approximately 2% of the dynamic instruction stream of a representative instruction mix. The one cycle savings results in a 21 percent improvement in the performance of the execution of the MVC instruction for the frequent case (84%) when the operand length is less than or equal to eight bytes and a 9 percent improvement in performance for the less frequent case (16%) in which the operand length is greater than eight bytes.

FIELD OF THE INVENTION

These inventions relate to digital computer systems and particularly to an improvement in the execution of frequently used movement of one storage location to a second storage location by predicting that the source and destination locations overlap destructively thereby allowing immediate execution of the move without having to stall the execution in a pipelined digital computer system until a determination of the condition can be calculated.

GLOSSARY OF TERMS

While dictionary meanings are also implied by certain terms used here, the following glossary of some terms may be useful.

ESA/390 refers to and is a mark for the International Business Machines Corporation mainframe system architecture used in the Enterprise Systems Architecture machines in use today. This architecture is the standard for mainframe architecture throughout the world, and using the existing instructions is important to enable use of the existing architecture.

MVC is short for MOVE CHARACTER, an existing ESA/390 instruction.

NC is short for AND CHARACTER, an existing ESA/390 instruction.

OC is short for OR CHARACTER, an existing ESA/390 instruction.

XOR is shod for XOR CHARACTER, an existing ESA/390 instruction.

MVZ is shod for MOVE ZONES, an existing ESA/390 instruction.

MVN is shod for MOVE NUMERICS, an existing ESA/390 instruction.

SAR1 is shod for the first storage operand address.

SAR2 is shod for the second storage operand address.

AGEN and AG are used interchangeably for address generation.

BACKGROUND OF THE INVENTION

As background for our invention we will review some IBM Technical Disclosure Bulletins, so that the reader can more quickly follow our discussion and understand how our invention differs from prior art. Initially, it will be understood that our invention provides a prediction mechanism for detecting destructive storage operand overlap for MVC and instructions that can have operands that potentially overlap in a like manner to the MVC instruction. The invention is applicable to predicting destructive operand overlap for address calculations of the type used in the ESA/390 processor architecture. That it can be easily extended to support other architecture addressing modes is demonstrated by expanding the detection to include an assumed 64 bit addressing mode.

International Business Machines Corporation publishes a Technical Disclosure Bulletin, known as the TDB, about inventions made in IBM for public information. Turning now to the TDBs in this ad, we note that Ngai et al in TDB 12-82, Vol. 25, No. 7A, pp. 3569-3576, publish a fast algorithm for handling destructive operand overlap move instruction execution. The algorithm is suitable for MOVE CHARACTER, MOVE NUMERICS, and MOVE ZONES instruction types. The determination of the destructive operand overlap condition; however, is assumed and is not specified. The prediction of this assumed condition, on the other hand, is the subject of our invention.

Beetcher et al in TDB 06-81, Vol. 24, No. 1A, pp. 192-197, define a Move Long Embellished (MLE) instruction in which the behavior of the instruction depends on whether operands are overlapped. The instruction definition is specified in their TDB; however, the mechanism for detecting storage operand overlap is not defined.

Ngai et al in TDB 06-76 Vol. 19, No. 1, pp. 61-64, publish a hardware mechanism for determining destructive storage operand overlap by using bits of the destination address and source address to access a read only storage ("ROS") which at each memory location contains an indicator as to whether storage operand overlap may occur from the combination (over-indication). All bits of the address are used. No explaination for supporting multiple addressing modes is provided. In addition, their method determines whether the condition exists for the dataflow width of the machine. In our invention, we predict precisely whether storage operands possess destructive operand overlap as indicated by the architecture. The condition is generated if any byte within the operands overlap. Trace analysis indicate that conditions for which operands overlap with the operand length being less than storage data bus widths of a doubleword commonly found in current high performance processor implementations is infrequent; therefore, little performance is lost by detecting overlap for the general case. In any case, our indication is precise and not an over-indication. Secondly, we detect the condition totally with logic and do not rely upon an array access. Therefore, our determination should be faster and more cell efficient than the published mechanism. Finally, the published mechanism does not predict the overlap condition from bases, displacements and operand length as we do, but from the address after they are generated.

Brooks in TDB 06-76 Vol. 19, No. 1, pp. 222-224, published an operand consistency attendent (OCA) to prevent simultaneous, incompatible accesses to data fields. The hardware mechanism described determines if the operands overlap by comparing beginning and ending operand addresses. As such, not only are operand beginning address calculated prior to the determination, but also ending addresses. A mechanism for speeding up the comparisons once these beginning and ending addresses are available that approximates that the operands overlap is presented. We, on the other hand, determine the storage operand overlap condition in parallel with the generation of the source and destination addresses (beginning addresses for the TDB). In addition, our indication is precise.

Baker et al in TDB 01-82 Vol. 24, No. 8, pp. 4018-4022, published algorithms for executing many instructions whose behavior is architected, when operands overlap, to proceed as if the operands were processed byte by byte. It is assumed that the detection of operand overlap is already known and the algorithm for the executions are then provided. No mechanism is shown for detecting the operand overlap condition which is the subject of our invention.

SUMMARY OF THE INVENTION

Our invention deals with the use of specialized hardware, that executes in parallel with the generation of the storage addresses, to predict whether two storage operands destructively overlap. The behavior of storage to storage instruction execution is often architected to proceed as if the instruction is executed on the storage operands byte by byte. This can be accomplished by executing all of these operations on a byte by byte basis; however, if source and destination operands do not destructively overlap, then the operation can be executed on multiple bytes in parallel and still appear to occur byte by byte. Therefore, the execution speed of the instruction can be improved by detecting that the storage operands overlap destructively, and if not, allowing the execution to proceed on multiple bytes at a time, but performing the operation on a byte by byte basis if the operands do overlap destructively. To meet architectural requirements, the destructive operand overlap condition must be known before the fetched data can be stored. In some cases, useful work can be accomplished while storage operand overlap is being determined; however, for the frequently used MOVE CHARACTER (MVC) instruction, no useful work is available to fill the gap. Therefore, the execution must stall until the operand overlap condition is determined.

In the past, destructive storage operand overlap has been detected by first calculating the storage addresses for the source and destination operands followed by a comparison of the storage addresses to determine if:

    0≦SAR1-SAR2≦L

in which SAR1 and SAR2 represent the storage operand addresses for the destination and the source operands, respectively, and L represents the length of the operands. In pipelined processors, such detection has taken at least one additional cycle beyond the generation of the storage addresses. Therefore, at least one stall cycle would be required before execution of the MVC instruction could proceed. Our invention allows the storage operand overlap condition for the MVC instruction to be determined directly from the base and displacement for both source and destination operands of the MVC instruction and the length of the operands as specified in the instruction, in parallel with the use of the bases and displacements for calculating the source and destination storage addresses. By performing this determination in parallel with the generation of the source and destination storage addresses, no stall cycles are required during the execution of the frequently invoked MVC instruction. A savings of one stall cycle for the MVC instruction alone, represents a 21% improvement in the execution speed of the MVC instruction for the more frequent case (84%) when the operand length is less than or equal to eight bytes and a 9% improvement for the case (16%) when the operand length is greater than eight bytes. Due to the frequency of the MVC instruction, this reflects in a net reduction in the CPI for a representative instruction mix, for the MVC instruction alone, of 0.02 CPI which is achieved with minimum additional hardware. The invention, designed for an ESA/390 processor, can predict destructive storage operand overlap for all addressing modes known to that architecture. It is also demonstrated that the invention can be extended to other architectures by expanding the predictor to support an assumed 64 bit addressing mode.

These and other improvements are set forth in the following detailed description. For a better understanding of the invention with advantages and features, refer to the description and to the drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

Our detailed description explains the preferred embodiments of our invention, together with advantages and features, by way of example with reference to the following drawings.

FIG. 1 shows all unique cases for which storage operands can possess destructive storage operand overlap.

FIGS. 2A-2C show all unique cases for which storage operands do not possess destructive storage operand overlap.

FIG. 3 shows an overview of the hardware required to predict destructive storage operand overlap.

FIG. 4 shows details of the overlap prediction logic block contained within the overview of FIG. 3.

FIG. 5 shows details of logic for determining whether the destination storage operand address resides in the highest 256 byte block of the virtual address space, resides in the lowest 256 byte block of the virtual address space, and the condition that wrapping occurs during the destination storage operand address calculation.

FIG. 6 shows details of logic for determining whether the source storage operand address resides in the highest 256 byte block of the virtual address space, resides in the lowest 256 byte block of the virtual address space, and the condition that wrapping occurs during the source storage operand address calculation.

DETAILED DESCRIPTION OF THE INVENTION

Before considering our preferred embodiments in detail, it is worthwhile to develop the conditions that will be used to predict that a source and destination address overlap destructively.

Architectures, such as the IBM ESA/390 architecture, may require that the execution of instructions on overlapped storage operands perform in an architected manner. This can require the detection of such overlapping conditions before the instruction can begin execution. Given the frequency of some of these type instructions, a prime example being the MOVE CHARACTER (MVC) instruction in ESA/390, and the number of cycles required for their execution for most invocations of the instruction, a substantial penalty may be payed when this process is implemented with a serial detection of operand overlap. This suggests the need for the fast determination of operand overlap. For the SS instruction MVC, just mentioned, and other SS instructions AND character (NC), OR character (OC), XOR CHARACTER (XC), MOVE ZONES (MVZ), and MOVE NUMERICS (MVN), found in the ESA/390 architecture, the conditions for overlapped operands can be expressed as:

    0≦SAR1-SAR2≦L

in which SAR1 and SAR2 represent the storage addresses for the destination and source operands, respectively, and L represents the length of the operands. Of the instructions contained in the above list, MVC occurs the most frequently in an instruction stream. For this reason, the above overlap will be referred to as MVC type overlap. Furthermore, overlap can also occur for other ESA/390 instructions. These instructions include the ESA 390 instructions PACK and ZAP in which overlap occurs when

    SAR2≦SAR1+L1<SAR2+L2

UNPK in which overlap occurs when

    SAR2≦SAR1+L1≦SAR2+(2 L2)-2

and TR and TRT in which overlap occurs when

    SAR2≦SAR1+L1<SAR2+255

MVC type overlap must be detected precisely whereas overlap for this latter group of instructions can be over indicated. Overindication of overlap can be accomplished by

    |SAR1-SAR2|≦15

for PACK, ZAP, and UNPK or by

    |SAR1-SAR2|≦255

for TR and TRT.

As already stated, MVC is one of the more frequent instructions that occurs in a representative instruction mix. For this reason, the mechanism used to detect overlap can impact the cycles per instruction, CPI, for a given design. In prior art, MVC overlap detection has consisted of calculating both storage operand addresses, SAR1 and SAR2, followed by a comparison of SAR1 with SAR2 and SAR1-SAR2 with L. Such an implementation can lead to an underutilization of the storage bus, resulting in a performance bottleneck, since the AGEN ALU is required for the calculation of SAR1, SAR2, and the comparison of SAR1 with SAR2. As an example of the degradation in performance that can result from the detection of overlap, consider the PU design for a high performance superscalar processor using the following pipeline structure:

    ID-AG-EX

for single cycle instructions and

    ______________________________________                                                   ID - AG - CA                                                                      μF - AG - EX                                                   ______________________________________                                    

where μF represents microword fetch, for two cycle instructions which have a storage access. In this pipeline ID stands for instruction decode, AG represents the address generation stage, CA represents data cache access, and EX represents the instruction execution. The put-away for the instruction is hidden; i.e., results of the execution can be by-passed as inputs to the required function unit for use in the following execution cycle. The PU is assumed to be designed with the capability to execute up to three ESA/390 instructions currently. A result of this capability is the inclusion of two address generation ALU's in the dataflow. The suggestion here is that for the SS instructions such as MVC, the source and destination storage addresses can be generated simultaneously during the AG cycle that follows decode of the MVC instruction. All instructions of the processor are microcode controlled with single cycle instructions invoking one microinstruction and multiple cycle instructions invoking a microcode routine. MVC falls into the multiple cycle instruction category; therefore, multiple microinstructions are invoked during its execution. For such a routine, the execution would result in the following pipeline sequence:

    ______________________________________                                         First microword  ID - AG - CA                                                  Second microword    μF - AG - EX                                            Third microword        μF - AG - EX                                         ______________________________________                                    

where μF represents microword fetch, with the sequence repeated to complete the instruction execution. The following describes a possible implementation of the MVC instruction which will be used in the following to describe our invention, the operand overlap prediction apparatus. For this implementation, the first microinstruction specifies a load from the storage location addressed by the first operand. During the AG cycle of this first microinstruction, both operand addresses are calculated by the two AGEN ALU's, and a fetch command for operand one is formulated and sent to the data cache. On the next cycle, data fetched from the data cache is placed on the data bus and accepted by the processor. Since the processor can by-pass data fetched from the cache to the data bus, it is conceivable that a store command could be formulated during this cycle for storing the fetched data into the data cache. Compliance with the architecture, however, requires that operand overlap be known before the data can be stored. With prior art, the storage operand addresses, SAR1 and SAR2, which are calculated during the AG cycle of the first instruction must be by-passed in the next cycle to overlap detection logic to determine overlap during the AG cycle of the second microinstruction. The results of the overlap detection are then used as a branch condition to determine which of two micro-routines is to be accessed to execute MVC in a fashion that conforms to the architecture. As a result, with prior ad, the second microinstruction becomes effectively a NOP that allows overlap to be determined before accessing the appropriate microroutine to store the fetched data. Consequently, the storage bus is underutilized. This underutilization can be reduced if the overlap condition can be predicted during the AG cycle of the first microword and made available as a branch condition for selecting the appropriate routing when fetching the second microword. In the following, our invention is presented that allows the prediction of the overlap condition in parallel with the calculation of the two storage operand addresses, SAR1 and SAR2. In this manner, one cycle can be saved for each invocation of the instructions that require the detection of MVC type overlap. Using a representative instruction mix, the cycles required to execute the MVC instruction for the frequent case (84%) in which MVC is invoked with an operand length less than or equal to eight is reduced from an average of 4.7 cycles to an average of 3.7 cycles, an improvement of 21%. For the less frequent case (16%) in which the operand length for MVC is greater than eight, the number of execution cycles is reduced from 11.8 cycles to 10.8 cycles, an improvement of 9%. The net reduction in the CPI is 0.02 which is achieved with minimum additional hardware.

Address conditions that lead to overlap can be divided into five cases. These cases are shown in FIG. 1. In the first case, overlap occurs because the source operand wraps across the high storage boundary to low storage and overlaps with the destination operand address at low storage. In the second case, the source operand and the destination operand both wrap from high storage to low storage. In this case, the destination operand lies above the source operand and continues at the low address position. In the third case, both the source and destination addresses begin in the same 256 byte block within storage with all of the source operand lying within this 256 byte block. In case four, both operands begin within the same 256 byte block somewhere in the middle of storage and both operands spill into the next sequential 256 byte block. Finally, in case five, the destination operand begins in the next sequential block from the source operand. The source operand spills into this sequential block and overlaps the destination. The non-overlap cases are comprised of all the remaining possibilities that are not included in the overlap cases. These cases are provided in FIGS. 2A-2C. All of the cases for both overlap and non-overlap are used in the following to develop our invention for detecting overlap for all addressing modes supported by the ESA/390 architecture. These modes included 24 and 31 bit access register modes. In addition, address calculation of a 64 bit base and 12 bit displacement will also be assumed. Twenty-four and thirty-one bit addressing modes are also included by virtue of the fact that they can be considered as subsets of the 24 and 31 bit access register modes provided in the ESA/390 architecture. The wrap cases such as cases 1 and 2 of FIG. 1 will be excluded from consideration for the addition of the 64 bit base with the 12 bit displacement by assuming that the MSB of the 64 bit address must be zero to have a valid address while wrapping is defined to occur at the 2⁶⁴ -1 address boundary. Thus memory addressing can not occur at the highest 256 byte block of the virtual address space for this addressing mode. In the discussion to follow, a two's complement number is represented by a capital letter, for example A. The two's complement number consists of a number of bits, m, that can be denoted as a_(i) where 0≦i≦m-1 with a₀ representing the most significant bit, MSB, and a_(m-1) representing the least significant bit, LSB. Furthermore, the notation A(i:j) where i≦j≦j≦m-1 will be used to denote a number comprised of the bits within A that are between and include i and j. Using this notation, the following theorems are proven as the basis for our invention for detecting MVC type overlap.

Theorem 1

The subtraction of two implicit, positive, two's complement numbers, A-B, using two's complement arithmetic will produce a carry from bit position i into the next most significant bit position, i-1, if A≧B where A=0∥A(i:m-1) and B=0∥B(i:m-1).

Proof:

For the case in which A(i:m-1)>B(i:m-1), some j such that a_(j=) 1 and b_(j) =0 and a_(p) =b_(p) for all p such that i≦p<j. To perform the two's complement subtraction, A-B, A is added to the one's complement of B with a hot one supplied into position m-1. But since B is one's complemented, then b_(p) =a_(p) while a_(j) 1 and b_(j) =1. Thus, A-B will produce a carry from j into j-1. At position j-1, however, either a_(j-1) =1 and b_(j-1) =0, or a_(j-) =0 and b_(j-1) =1 since b_(j) =a_(j). Therefore, the carry into j-1 added to a_(j-1) and b_(j-1) will produce a carry into j-2. Identical considerations apply to each bit position q, i+1≦q≦j- 2, as applied to j-1 so that at bit position i, the carry into i is a one while either a_(i) or b_(i) but not both are one. A carry at bit position i into i-1, therefore, will be produced.

For the case in which A(i:m-1)=B(i:m-1), a_(j) =b_(j) for all i≦j≦m-1. Since B is to be complemented before the addition, then each and every bit position, j, will consist of a one to be added to a zero. Therefore, since a hot one is provided into the LSB position, a carry will be produced at m-1. This carry propagates into the position m-2 at which a carry is produced into m-3. The carry continues to propagate through each and every bit position, j, producing a carry from bit i into i-1.

QED

Theorem 2

The subtraction of two implicit, positive, two's complement numbers A-B using two's complement arithmetic will not produce a carry from bit position i into the more significant position i-1 if A<B where A=0∥A(i:m-1) and B=0∥B(i:m-1).

Proof:

For A(i:m-1)<B(i:m-1), some j such that a_(j) =0 and b_(j) =1 and a_(p) =b_(p) for all p such that i≦p<j. To perform the two's complement subtraction, A-B, A is added to the one's complement of B with a hot one supplied into position m-1. But since B is one's complemented, then b_(p) =a_(p) while a_(j) =0 and b_(j) =0. Because a_(j) and b_(j) are both zero's, then the carry from into j-1 will be a zero no matter the value of c_(j+1), the carry into position j. Thus, A-B will not produce a carry from j into j=1. At position j-1 either a_(j-1) -1 and b_(j-1) =0, or a_(j-1) =0 and b_(j-1) =1 since b_(j) =a_(j). Therefore, the lack of a carry into j-1 implies that the addition of a_(j-1), b_(j-1) and the carry into j-1, c_(j-1), will not produce a carry into j-2. Identical considerations apply to each bit position q, i+1≦q≦j-2 as applied to j-1 so that at bit position i, the carry into i is a zero while either a_(i) or b_(i) but not both are one. Therefore, no carry will be produced from bit i into i-1.

QED

The continued development of our invention for detecting MVC type operand overlap makes use of the following notation. First, SAR2 and SAR1 will be designated by A and B, respectively, each having individual bits designated as a_(i) and b_(i), respectively, where 0≦i≦63. The eight bit operand length designated as OL(0:7) will be designated as L when concatenated on the left with 56 zero's. Therefore, L, is zero for 0≦i≦55 and is OL(0:7) for 56≦i≦63. The following add/subtract combinations of A, B, and L will be needed in the following discussion. These combinations along with their designations are: 1. A-B designated as Δ having individual bits designated as δ_(i), and carries from one bit position to the next designated as κ_(i) ; 2. A+L designated as Ε having individual bits ε_(i) and carries designated as γ_(i) ; 3. Δ+L designated as S with individual bits S_(i) and carries designated as c_(i) ; and 4. Λ-B designated as S.sup. having individual bits designated as S_(i).sup. and carries designated as λ_(i). This notation is summarized in Table 1.

                  TABLE 1                                                          ______________________________________                                         Notation for Developing MVC Type Overlap Detect Apparatus                                               Char    Bit  Carry                                    Entity       Representation                                                                             Rep     Rep  Rep                                      ______________________________________                                         SAR2         --          A       a.sub.i                                                                             --                                       SAR1         --          B       b.sub.i                                                                             --                                       SAR2 - SAR1  A - B       Δ δ.sub.i                                                                       κ.sub.i                            SAR2 + L     A + L       E       ε.sub.i                                                                     γ.sub.i                            (SAR2 - SAR1) + L                                                                           Δ + L S       S.sub.i                                                                             c.sub.i                                  (SAR2 + L) - SAR1                                                                           E - B       S.sup.  S.sub.i.sup.                                                                        λ.sub.i                           ______________________________________                                    

Using the above notation, the following theorems hold true.

Theorem 3

If storage operands 1 and 2 possess MVC type overlap and SAR1 is mapped above SAR2 when SAR2 is within the high 256 byte block and SAR1 is within the low 256 byte block of the address space, then δ_(i) =1 for 0≦i≦55.

Proof:

The theorem must be proven for each of the cases shown in FIG. 1 for each of the three addressing modes provided by the ESA/390 architecture. The representation of storage address for each of the addressing modes are shown in Table 2 on page 17.

                  TABLE 2                                                          ______________________________________                                         Address Representation for ESA/390 and                                         Assumed 64 bit addressing mode                                                 Mode     Address Representation                                                ______________________________________                                         24 bit access                                                                           a.sub.0 a.sub.1 . . . a.sub.31 0 0 . . . 0 a.sub.40 a.sub.41 . .               . a.sub.55 a.sub.56 a.sub.57 . . . a.sub.63                           register (AR                                                                   24 bit) mode                                                                   31 bit access                                                                           a.sub.0 a.sub.1 . . . a.sub.31 0 a.sub.33 . . . a.sub.55                       a.sub.56 a.sub.57 . . . a.sub.63                                      register (AR                                                                   31 bit) mode                                                                   64 bit   0 a.sub.1 . . . a.sub.55 a.sub.56 a.sub.57 . . . a.sub.63             addressing                                                                     ______________________________________                                    

In Table 2 bit positions of SAR2 that are known to be zero are shown to be zero while bit positions that are either one or zero are represented as a subscripted a, the subscript representing the bit position within the variable, since SAR2 has earlier been represented as A. SAR1 can be similarly represented by substituting b for a in the representation. Using this representation, each of the cases shown in FIG. 1 must be considered. For the cases in which SAR2 is in the high 256 byte block and SAR1 within the low 256 byte block of the address space, mapping SAR1 above SAR2 can be accomplished by extending the address by one bit position and forcing the bit position to a one. Thus, for a 24 bit address space, a 25th bit would be concatenated to the MSB of the address and be forced to a one. For the representation of the address as shown in Table 2, the address space is already extended for each of the addressing modes with bit positions being zero's as shown in the table. Mapping SAR1 above SAR2 for this representation: therefore, consists only of forcing the next more significant bit position to a 1. For example, 24 bits of address would required the least 24 bit positions of the address which for the representation in Table 2 correspond to bits 40 to 63. Mapping SAR1 above SAR2 for 24 bit addressing would consist of forcing bit 39 to a one. Similarly, for 31 bit addressing, mapping SAR1 above SAR2 consists of forcing bit 32 of the address to a one.

Theorem 3, Case 1

Case 1 is characterized by A lying within the high 256 byte block of the address space and B lying within the low 256 byte block with the most significant bits of A equal to that of B. Because A lies within the high 256 byte block and B lies within the low order 256 byte block within the address space, B must be mapped above A. In addition, B(56:63)≦Ε(56:63) and Ε(56:63)<A(56:63) so that A(56:63)>B(56:63). Therefore, by theorem 1, κ₅₆ =1. All three addressing modes are considered below.

AR 24 Bit Mode For this addressing mode, mapping B above A consists of forcing bit 39 to a logic 1. Because bit positions more significant than 39 are equal, a_(i) =b_(i) for i≦38. As a result, A-B can be represented as: ##EQU1## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position 40≦i≦55 possesses two ones to be added to the carry into that position, δ_(i) =1 with κ_(i) =1 for all 40≦i≦55. At bit position 39, two zero's are to be added with κ₄₀ which is one so that δ₃₉ =1 with κ₃₉ =0. For each bit position 0≦i≦38 a zero is added to a one and a carry of zero. Thus, δ_(i) =1 and κ_(i) =0 for all 0≦i≦38 from which it follows that δ_(i) =1 for all 0≦i≦55.

AR 31 Bit Mode For this addressing mode, mapping B above A consists of forcing bit 32 to a logic 1. Because bit positions more significant than 32 are equal, a_(i) =b_(i) for i≦31. As a result, A-B can be represented as: ##EQU2## with a hot one implicitly forced at bit position 63. As for 24 Bit addressing, because κ₅₆ =1 and because each bit position 33≦i≦55 possesses two ones to be added to the carry into that position, δ_(i) =1 and κ_(i) =1 for all 33≦i≦55. At bit position 32, two zero's are to be added with κ₃₃ which is one so that δ₃₂ =1 with κ₃₂ =0. For each bit position 0≦i≦31 a zero is added to a one and a carry of zero. Thus, δ_(i) =1 and κ_(i) =0 for all 0≦i≦31 from which it follows that δ_(i) =1 for all 0≦i≦55.

64 Bit Addressing Case 1 can not occur for 64 bit addressing. As a result, no mapping of B above A must be done for 64 bit addressing to accommodate this case.

Theorem 3, Case 2

Case 2 is characterized by both B and A lying within the highest order 256 byte block in the address space with A(56:63)<B(56:63). Thus by theorem 2, κ₅₆ =0.

AR 24 Bit Mode Bit positions more significant than bit 40 are equal for B and A so that a_(i) =b_(i) for i≦39. As a result, A-B can be represented as: ##EQU3## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added to the carry into that bit position, the result at each bit is δ_(i) =1 with κ_(i) =0. Therefore, δ_(i) =1 for all 0≦i≦55.

AR 31 Bit Mode Bit positions more significant than bit 33 are equal for B and A so that a_(i) =b_(i) for i≦32. As a result, A-B can be represented as: ##EQU4## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one to be added to a zero and the carry into that bit position, then δ_(i) =1 with κ_(i) =0. Therefore, δ_(i) =1 for all 0≦i≦55.

64 Bit Addressing Case 2 can not occur for 64 bit addressing.

Theorem 3, Cases 3 and 4

These cases are characterized by B and A both lying within identical 256 byte blocks of the address space with A(56:63)<B(56:63). By theorem 2, κ₅₆ =0. The 256 byte block in which both B and A lie is arbitrary. AR 24 Bit Mode Bit positions more significant than bit 40 are equal for B and A so that a_(i) =b_(i) for i≦39. As a result, A-B can be represented as: ##EQU5## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one to be added with a zero and the carry into that bit position, δ_(i) =1 and κ_(i) =0. Thus, δ_(i) =1 for all 0≦i≦55.

AR 31 Bit Mode Bit positions more significant than bit 33 are equivalent for B and A so that a_(i) =b_(i) for i≦32. As a result, A-B can be represented as: ##EQU6## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one to be added with a zero and the carry into that bit position, δ_(i) =1 with κ_(i) =0. Thus δ_(i) =1 for all 0≦i≦55.

64 Bit Addressing A-B can be represented for 64 bit addressing for this case as: ##EQU7## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one to be added with a zero and the carry into that bit position, δ_(i) =1 and κ_(i) =0. Thus, δ_(i) =1 for all 0≦i≦55.

Theorem 3, Case 5

In this case, B lies in the 256 byte block immediately above the 256 byte block within which A lies. In addition, B(56:63)≦Ε(56:63) and Ε(56:63)<A(56:63). Thus A(56:63)>B(56:63) so that by theorem 1, κ₅₆ =1.

AR24 Bit Mode Since B lies in the 256 byte block immediately above that in which A lies, there exist a position j where 40≦j≦55 such that a_(j) 0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU8## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position j+1≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 with κ_(i) =1 for j+1≦i≦55. At bit position j, both a_(j) and b_(j) are zeros with κ_(j+=1) 1. Therefore, δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, one and only one of the addends is a one with the carry into that bit position equal to zero. Therefore, δ_(i) =1 for 0≦i≦j-1 from which it follows that δ_(i=) 1 for all 0≦i≦55.

AR 31 Bit Mode Since B lies in the 256 byte block immediately above that in which A lies, there exist a position j where 33≦j≦55 such that a_(j) =0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU9## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position j+1≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =1 for all j+1≦i≦55. At bit position j, both a_(j) and b_(j) are zeros with the κ_(j+1) =1. Therefore, δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, one and only one of the addends is a one with the carry into that bit position equal to zero. Therefore, δ_(i) =1 for 0≦i≦j-1 from which it follows that δ_(i) =1 for all 0≦i≦55.

64 Bit Addressing Since B lies in the 256 byte block immediately above that in which A lies, there exist a position j where 1≦j≦55 such that a_(j) =0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU10## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position j+1≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 with κ_(i) =1 for all j+1≦i≦55. At bit position j, both a_(j) and b_(j) are zeros with κ_(j+1) =1. Therefore, δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, one and only one of the addends is a one with the carry into that bit position equal to zero. Therefore, δ_(i) =1 for 0≦i≦j-1 from which it follows that δ_(i) =1 for all 0≦i≦55.

QED

Theorem 4

If storage operands 1 and 2 do not possess MVC type overlap and SAR1 is mapped above SAR2 when SAR2 is within the high 256 byte block and SAR1 is within the low 256 byte block of the address space, then δ_(i), the result of the subtraction, SAR2-SAR1, will not be all ones for 0≦i≦55 except for nonoverlap cases 1, 6, and 11 when a carry is produced from bit 56 into bit 55 (κ₅₆ =1), and nonoverlap case 3.

Theorem 4, Case 1

Case 1 is characterized by A lying within the high 256 byte block of the address space and B lying within the low 256 byte block with the most significant bits of A equal to those of B. Because A lies within the high 256 byte block and B lies within the low order 256 byte block within the address space, B must be mapped above A. In addition, A(56:63) may be less than B(56:63) in which case by theorem 2 κ₅₆ =0 (subcase 1), or A(56:63) may be greater than or equal to B(56:63) in which case by theorem 1 κ₅₆ =1 (subcase 2). Both of these subcases must be considered for all three addressing modes.

AR 24 Bit Mode For this addressing mode, mapping B above A consists of forcing bit 39 to a logic 1. Because bit positions more significant than 39 are equal, a_(i) =b_(i) for i≦38. As a result, A-B can be represented as: ##EQU11## with a hot one implicitly forced at bit position 63.

Subcase 1 Consider bit position 55. Because bit position 55 possesses two ones to be added with κ₅₆ which is zero, δ₅₅ =0. Therefore, for this subcase, δ_(i) is not all one's for 0≦i≦55.

Subcase 2 Because κ₅₆ =1 and because each bit position 40≦i≦55 possesses two ones to be added with the carry into that position, δ_(i) =1 and κ_(i) =1 for all 40≦i≦55. At bit position 39, two zero's are to be added with κ₄₀ which is 1. Therefore, δ₃₉ =1 and κ₃₉ =0. For each bit position 0≦i≦38 a zero is added to a one and the carry into that bit position. Since κ₃₉ =0, then δ_(i) =1 for all 0≦i≦38 from which it follows that δ_(i) =1 for all 0≦i≦55.

AR 31 Bit Mode For this addressing mode, mapping B above A consists of forcing bit 32 to a logic 1. Because bit positions more significant than 32 are equal, a_(i) =b_(i) for i≦31. As a result, A-B can be represented as: ##EQU12## with a hot one implicitly forced at bit position 63.

Subcase 1 Consider bit position 55. Because bit position 55 possesses two ones to be added with κ₅₆ which is zero, δ₅₅ =0. Therefore, for this subcase, δ_(i) is not all one's for 0≦i≦55.

Subcase 2 Because κ₅₆ =1 and because each bit position 33≦i≦55 possesses two ones to be added with the carry into that position, δ_(i) =1 and κ_(i) =1 for all 33≦i≦55. At bit position 32, two zero's are to be added with κ₃₃ which is 1. Therefore, δ₃₂ =1 and κ₃₂ 0. For each bit position 0≦i≦31 a zero is added to a one and the carry into that bit position. Since κ₃₂ =0, then δ_(i) =1 for all 0≦i≦31 from which it follows that δ_(i) =1 for all 0≦i≦55.

64 Bit Addressing Case 1 can not occur for 64 bit addressing. Thus, B does not need to be mapped above A for the 64 bit addressing mode for this case.

Theorem 4, Case 2

Case 2 is characterized by both B and A lying within the highest order 256 byte block in the address space with A(56:63)≧B(56:63). Thus, by theorem 1, κ₅₆ =1.

AR 24 Bit Mode Bit positions more significant than bit 40 are equal for B and A so that a_(i) =b_(i) for i≦39. As a result, A-B can be represented as: ##EQU13## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added to the carry into that bit position, δ_(i) =0 and κ_(i) =1 for all 0≦i≦55. Therefore, δ_(i) ≠1 for all 0≦i≦55.

AR 31 Bit Mode Bit positions more significant than bit 33 are equivalent for B and A so that a_(i) =b_(i) for i≦32. As a result, A-B can be represented as: ##EQU14## with a hot one implicitly forced at bit position 63. Because δ_(i) =1 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =0 and κ_(i) =1. Therefore, δ_(i) ≠1 for all 0≦i≦55.

64 Bit Addressing Case 2 can not occur for 64 bit addressing; therefore, it does not need to be addressed.

Theorem 4, Case 3

Case 3 is characterized by B and A lying within identical 256 byte blocks of the address space with B(56:63)>Ε(56:63)>A(56:63). Thus, A(56:63)<B(56:63) so that by theorem 2, κ₅₆ =0. The 256 byte block is arbitrary.

AR 24 Bit Mode Bit positions more significant than bit 40 are equal so that a_(i) =b_(i) for i≦39. As a result, A-B can be represented as: ##EQU15## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =0 for each and every bit position. Therefore, δ_(i) =1 for all 0≦i≦55.

AR 31 Bit Mode Bit positions more significant than bit 33 are equal so that a_(i) =b_(i) for i≦32. As a result, A-B can be represented as: ##EQU16## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =0 for each and every bit position. Therefore, δ_(i) =1 for all 0≦i≦55.

64 Bit'Addressing A-B for the 64 bit addressing mode can be represented as: ##EQU17## with a hot one implicitly forced at bit position 63. Because κ₅₆ =0 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =0 for each and every bit position. Therefore, δ_(i) =1 for all 0≦i≦55.

In summary for Case 3, δ_(i) =1 for all 0≦i≦55.

Theorem 4, Cases 4 and 5

These cases are characterized by B and A lying within identical 256 byte blocks of the address space with A(56:63)≧B(56:63). Thus by theorem 1, κ₅₆ =1. The 256 byte block is arbitrary.

AR 24 Bit Mode Bit positions more significant than bit 40 are equal so that a_(i) =b_(i) for i≦39. As a result, A-B can be represented as: ##EQU18## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =0 and κ_(i) =1 for each and every bit position. Therefore, δ_(i) ≠1 for all 0≦i≦55.

AR 31 Bit Mode Bit positions more significant than bit 33 are equal so that a_(i) =b_(i) for i≦32. As a result, A-B can be represented as: ##EQU19## with a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) =0 and κ_(i) =1 for each and every bit position. Therefore, δ_(i) ≠1 is for all 0≦i≦55.

64 Bit Addressing A-B for 64 bit addressing mode can be represented as: ##EQU20## a hot one implicitly forced at bit position 63. Because κ₅₆ =1 and because each bit position 0≦i≦55 possesses a single one and a single zero to be added with the carry into that bit position, δ_(i) 0 and κ_(i) =1 for each and every bit position. Therefore, δ_(i) ≠1 for all 0≦i≦55.

In summary for Cases 4 and 5, δ_(i) ≠1 for all 0≦i≦55.

Theorem 4, Cases 6 and 11

For these cases, B lies in the 256 byte block immediately above the 256 byte block within which A lies. Also A(56:63) may be either less than B(56:63) in which case from theorem 2 κ₅₆ =0 (subcase 1), or A(56:63) may be greater than or equal to B(56:63)in which case from theorem 1 κ₅₆ =1 (subcase 2). Both subcases must be considered for each of the three addressing modes.

AR 24 Bit Mode Since B lies in the 256 byte block immediately above that in which A lies, there exist a position j where 40≦j≦55 such that a_(j) =0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU21## with a hot one implicitly forced at bit position 63.

Subcase 1 Consider bit position 55. At this position, two one's are to be added with κ₅₆ which is zero. As a result, δ₅₅ =0 so that δ_(i) ≠1 for all 0≦i≦55.

Subcase 2 Because κ₅₆ =1 and because each bit position (j+1)≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =1 for all (j+1)≦i≦55. At bit position j, two zero's are to be added to κ_(j+1) =1 so that δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, a one and a zero are to be added with the carry into that bit position. Since κ_(j) =0, δ_(i) =1 and κ_(i) =0 for all 0≦i≦(j-1). Therefore, δ_(i) =1 for 0≦i≦55.

AR 31 Bit Addressing Since B lies in the 256 byte block immediately above that in which A lies, there exist a j where 33≦j≦55 such that a_(j) =0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU22## with a hot one implicitly forced at bit position 63.

Subcase 1 Consider bit position 55. At this position, two one's are to be added with κ₅₆ which is zero. As a result, δ₅₅ =0 so that δ_(i) ≠1 for all 0≦i≦55.

Subcase 2 Because κ₅₆ =1 and because each bit position (j+1)≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =1 for all (j+1)≦i≦55. At bit position j, two zero's are to be added to κ_(j+1) =1 so that δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, a one and a zero are to be added with the carry into that bit position. Since κ_(j) =0, δ_(i) =1, and κ_(i) =0 for all 0≦i≦(j-1). Therefore, δ_(i) =1 for 0≦i≦55.

64 Bit Addressing Since B lies in the 256 byte block immediately above that in which A lies, then there exist a j where 0≦j≦55 such that a_(j) =0 and b_(j) =1 with a_(p) =1 and b_(p) =0 for j≦p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU23## with a hot one implicitly forced at bit position 63.

Subcase 1 Consider bit position 55. At this position, two one's are to be added with κ₅₆ which is zero. As a result, δ₅₅ =0 so that δ_(i) ≠1 for all 0≦i≦55.

Subcase 2 Because κ₅₆ =1 and because each bit position (j+1)≦i≦55 possesses two one's that are to be added with the carry into that bit position, δ_(i) =1 and κ_(i) =1 for all (j+1)≦i≦55. At bit position j, two zero's are to be added to κ_(j+1) =1 so that δ_(j) =1 and κ_(j) =0. At each and every bit position between 0 and j-1, a one and a zero are to be added with the carry into that bit position. Since κ_(i) =0, δ_(i) =1, and κ_(i) =0 for all 0≦i≦j-1. Therefore, δ_(i) =1 for 0≦i≦55.

In summary for Cases 6 and 11, δ_(i) ≠1 for all 0≦i≦55 if κ₅₆ =0. If κ₅₆ =1 then δ_(i) =1 for all 0≦i≦55.

Theorem 4, Case 7

In this case, A lies in the 256 byte block immediately above the 256 byte block within which B lies. Though A(56:63) may be either less than B(56:63) in which case from theorem 2 κ₅₆ =0 (subcase 1), or A(56:63) may be greater than or equal to B(56:63)in which case from theorem 1 κ₅₆ =1 (subcase 2), the two subcases can be considered simultaneously for each of the addressing modes.

AR 24 Bit Mode Since A lies in the 256 byte block immediately above that in which B lies, there exist a position j where 40≦j≦55 such that a_(j) =1 and b_(j) =0 with a_(p) =0 and b_(p) =1 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU24## with a hot one implicitly forced at bit position 63. Consider bit position j. At this position, two ones are to be added with the carry into that bit position. As a result, κ_(j) =1 despite whether κ_(j+1) =0 or κ_(j+1) =1. At bit position j-1 a one and a zero are to be added with κ_(j). Therefore, since κ_(j) =1, δ_(j-1) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55.

Access Register with 31 Bit Addressing Since A lies in the 256 byte block immediately above that in which B lies, there exist a position j where 33≦j≦55 such that a_(j) =1 and b_(j) =0 with a_(p) =0 and b_(p) =1 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU25## with a hot one implicitly forced at bit position 63. Consider bit position j. At this position, two ones are to be added with the carry into that bit position. As a result, κ_(j) =1 despite whether κ_(j+1) =0 or κ_(j+1) =1. At bit position j-1 a one and a zero are to be added with κ_(j). Therefore, since κ_(j) =1, δ_(j-1) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55.

64 Bit Addressing Since A lies in the 256 byte block immediately above that in which B lies, there exist a position j where 1≦j≦55 such that a_(j) =1 and b_(j) =0 with a_(p) 0 and b_(p) =1 for j<p≦55. In addition, a_(i) =b_(i) for i<j. As a result, A-B can be represented as: ##EQU26## with a hot one implicitly forced at bit position 63. Consider bit position j. At this position, two ones are to be added with the carry into that bit position.

As a result, κ_(j) =1 despite whether κ_(j+1) =0 or κ_(j+1) =1. At bit position j-1 a one and a zero are to be added with κ_(j). Therefore, since κ_(j) =1, δ_(j-1) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55.

In summary for Case 7, δ_(i) ≠1 for all 0≦i≦55.

Theorem 4, Cases 8, 9, 10, and 12

For these cases, A and B lie in 256 byte blocks that are separated by at least one 256 byte block. All address modes can be treated the same for these cases. For this cases, there exist at least one bit position j between 1 and 55 where a_(j) ≠b_(j) and a_(i) =b_(i) for all i<j.

First consider bit position j when a_(j) =b_(j) =1. For this condition, κ_(j) =1 despite whether κ_(j+1) =0 or κ_(j+1) =1. At position j-1 a one and a zero are added to κ_(j) producing δ_(j-1) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55.

Next consider the condition that a_(j) =b_(j) =0 with κ_(j+1) 0. The result of the addition of a_(j), b_(j) and κ_(j+1) is δ_(j) =0 from which it also follows that δ_(i) ≠1 for all 0≦i≦55.

Finally consider the case that a_(j) =b_(j) =0 with κ_(j+1) =1. In this case, δ_(j) =1 and κ_(j) =0. Since b_(i) =a_(i) for i<j, and κ_(j) =0, then δ_(i) =1 and κ_(i) =0 for all 0≦i<j. For κ_(j+1) =1, however, either both addends at j+1 are one and κ_(j+2) =0 (subcase 1), one of the addends is a one while the other is a zero and κ_(j+2) =1 (subcase 2), or both addends are one and κ_(j+2) =1. For subcases 1 and 2, δ_(j+1) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55. For subcase 3 δ_(j+1) =1, however, since κ_(j+2) =1 the identical three subcases arise at bit position j+ 2. Therefore, for δ_(j+2) =1, both addends at j+2 must be one with κ_(j+3) =1, or δ_(i+2) =0 from which it follows that δ_(i) ≠1 for all 0≦i≦55. Such an argument continues bitwise for (j+1)≦p≦55 so that for δ_(p) =1 for all (j+1)≦p≦55, it follows that a_(p) =b_(p) =1. Therefore, a_(p) =1 while b_(p) =0 from which it follows that B must lie within the 256 byte block immediately above the 256 byte block within which A resides for δ_(i) =1 for all 0≦i≦55. But this conflicts with the assumption for these cases that B and A are separated by one or more 256 byte blocks. As a result, δ_(i) ≠1 for all 0≦i≦55

In summary for Cases 8, 9, 10, and 12, δ_(i) ≠1 for all 0≦i≦55.

From the considerations of each of the 12 cases, it can be seen that if storage operands 1 and 2 do not contain MVC type overlap, then δ_(i) ≠1 for all 0≦i≦55 except for nonoverlap Cases 1, 6, and 11 when κ₅₆ =1 and for nonoverlap Case 3.

QED

Theorem 5

If δ_(i), the result of the subtraction SAR2-SAR1, is a logic 1 for all 0≦i≦55, then c.sub.₅₆, the carry produced from bit position 56 into bit position 55 during the addition (SAR2-SAR1)+L is a one iff the storage operands contain a MVC type overlap.

Proof:

Proof of if

By the Commutative property of addition, SAR2(55:63)-SAR1(55:63)+L(55:63) can be produced by either Δ(55:63)+L(55:63) or Ε(55:63)-B(55:63). As a result,

    S.sub.55 S.sub.55.sup.

But

    S.sub.55 =δ.sub.55  L.sub.55  c.sub.56

which since L₅₅ =0 becomes

    S.sub.55 δ.sub.55  c.sub.56

Since,

    δ.sub.55 =a.sub.55  b.sub.55  κ.sub.56

then

    S.sub.55 =a.sub.55  b.sub.55  κ.sub.56  c.sub.56

Similarly,

    S.sub.55.sup. =ε.sub.55  b.sub.55  λ.sub.56

which since

    ε.sub.55 =a.sub.55  L.sub.55  λ.sub.56 =a.sub.55 λ.sub.56

becomes

    S.sub.55.sup. =a.sub.55  γ.sub.56  b.sub.55  λ.sub.56 =a.sub.55  b.sub.55  γ.sub.56  λ.sub.56

Since S₅₅ =S₅₅.sup. then

    a.sub.55  b.sub.55  κ.sub.56  c.sub.56 =a.sub.55  b.sub.55 γ.sub.56  λ.sub.56

and

    κ.sub.56  c.sub.56 =γ.sub.56  λ.sub.56

Each of the five MVC type overlap cases must now be considered.

Theorem 5, overlap Cases 1 and 5

For cases 1 and 5, Ε(56:63)≧B(56:63). By Theorem 1, λ₅₆ =1. In addition, A(56:63)>B(56:63) so that by Theorem 1 κ₅₆ =1. Finally, A(56:63)+L(56:63) falls into the next sequential 256 byte of the address space so that the carry, γ₅₆, is also a one. Substituting these into:

    κ.sub.56  c.sub.56 =γ.sub.56  λ.sub.56

gives:

    1 c.sub.56 =1 1

    c.sub.56 =0

    c.sub.56 =1

Theorem 5, overlap Cases 2 and 4

For cases 2 and 4, A(56:63)<B(56:63) and Ε(56:63)<B(56:63). By Theorem 2, κ₅₆ =0 and λ₅₆ =0. As in case 1, A(56:63)+L(56:63) crosses a 256 byte boundary so that γ₅₆ =1. From these identities:

    0 c.sub.56 =1 0

    c.sub.56 =1

Theorem 5, overlap Case 3

For case 3, A(56:63)<B(56:63) and Ε(56:63)≧B(56:63). By Theorems 2 and 1, respectively, κ₅₆ =0 and λ₅₆ =1. A(56:63)+L(56:63) does not cross a 256 byte boundary so that λ₅₆ =0. From these identities:

    0 c.sub.56 =0 1

    c.sub.56 =1

Proof of only if

To prove only if, it must be shown that when δ_(i) =1 for all 0≦i≦55 and the operands do not contain a MVC type overlap, then c₅₆ is a zero. From Theorem 4, the cases that must be considered are nonoverlapped case 3 and cases 1, 6, and 11 when κ₅₆ =1.

Theorem 5, nonoverlap Case 3

For this case, A(56:63)<B(56:63) and Ε(56:63)<B(56:63). From Theorem 2, κ₅₆ =0 and λ₅₆ =0. Since A(56:63)+L(56:63) does not cross a 256 byte boundary, then γ₅₆ =0. Thus,

    0 c.sub.56 =0 0

    c.sub.56 =0

Theorem 5, nonoverlap Cases 1 and 6

For these cases, δ_(i) =1 for all 0≦i≦55 iff κ₅₆ =1. Therefore, only the case when κ₅₆ =1must be considered. In addition Ε(56:63)<B(56:63) so that by theorem 2 λ₅₆ =0. Finally, A(56:63)+L(56:63) crosses a 256 byte boundary so that γ₅₆ =1. Substituting these carries into the carry relationship derived above produces:

    1 c.sub.56 =1 0

    c.sub.56 =1

    c.sub.56 =0

Theorem 5, nonoverlap Case 11

For this case, δ_(i) =1 for all 0≦i≦55 iff κ₅₆ =1. From theorem 1, for κ₅₆ =1, then A(56:63)≧B(56:63). But, Ε(56:63)≧A(56:63) from which it follows that Ε(56:63)≧B(56:63). From this later result, by theorem 1, λ₅₆ =1. Also, A(56:63)+L(56:63) does not cross a 256 byte boundary so that γ₅₆ =0. Substituting these carries into the carry relationship derived above produces:

    1 c.sub.56 =0 1

    c.sub.56 =1

    c.sub.56 =0

QED

Theorem 6

Storage operands 1 and 2 possess MVC type overlap iff when SAR2 is within the high 256 byte block and SAR1 is within the low 256 byte block of the address space, then SAR1 is mapped above SAR2, and the operation (SAR2-SAR1)+L produces a carry from bit position 56 into position 55 and a result which is all zero's at every bit position i such that 0≦i≦55

Proof:

Proof of if

By Theorem 3, if two operands contain MVC overlap and SAR1 is mapped to the 256 byte block immediately succeeding SAR2 if SAR1 lies in the lowest 256 byte block and SAR2 lies in the highest 256 byte block, then SAR2-SAR1 produces all ones at each bit position i such that 0≦i≦55. Since L consists of 56 zero's concatenated to the left of OL(0:7) and by Theorem 5 c₅₆ =1, then each bit i for 0≦i≦55 will consist of a one and zero added to a carry of one into the bit. The result will be a zero with a carry produced into the left adjacent bit so that the result is zero for all 0≦i≦55.

Proof of only if

Assume that storage operands 1 and 2 do not possess MVC type overlap. Furthermore, assume S_(i) =0 for all 0≦i<55 and that c₅₆ =1. But for S_(i) =0 for all 0≦i≦55 when c₅₆ =1, δ_(i) =1 for all 0≦i≦55. By theorem 5, however, δ_(i) =1 for all 0≦i≦55 and c₅₆ =1 iff the storage operands possess MVC type overlap. Therefore, the assumption that the storage operands are free of MVC type overlap is erroneous.

QED

Theorem 6 provides the conditions to be used to detect MVC type overlap. In summary, the detection of MVC type overlap consists of the following. First, it must be detected that SAR1 lies in the lowest 256 byte block (SAR1LO) when SAR2 lies in the highest 256 byte block (SAR2HI) of the virtual address space. If this case occurs (REMAP1), then SAR1 must be mapped to the 256 byte block immediately above the highest 256 byte block. Otherwise, SAR1 is not to be remapped. With this mapping of SAR1, SAR1 is to be subtracted from SAR2. To this result is added L, the concatenation of 56 zero's with the operand length. If the results of this last addition contains all zero's for all i such that 0≦i≦55 and the carry from bit 56 into 55 is a one, then the operands contain MVC type overlap. In the following, the further development of these conditions into a form amenable to hardware prediction of MVC type overlap is pursued.

The address calculation for ESA/390 instructions that can exhibit MVC overlap consist of the addition of a base with a 12 bit displacement. For access register mode using 24 bit addressing, the addition consists of adding the 12 bit displacement to an access register concatenated with eight zero's concatenated with a 24 bit base. For access register mode using 31 bit addressing, the addition consists of adding the 12 bit displacement to an access register concatenated with a zero concatenated, with a 31 bit base. For 64 bit mode, the calculation consists of adding the 12 bit displacement to a 0 concatenated with 63 bits of the base. In the following, D₂ and D₁ will be used to represent 64 bit numbers consisting of 52 zero's concatenated to the left of the 12 bit displacement, DP(0:11). D₂ will be used to represent this form of the displacement for storage operand two while D₁ will be used to represent the displacement for storage operand one. The 12 least significant bits of D₂ and D₁ will be designated as d_(2i) and d_(1i), respectively, where 52≦i≦63. In addition, the base for operands one and two will be designated as B₁ and B₂, respectively, with the individual bits designated as b_(1i) and b_(2i) where 0≦i≦63. The base designated in this fashion is understood to include the concatenation of the access register with the actual base for access register mode as described above. Note that B which was previously used to represent SAR1 is now used to represent the base for address calculations.

Using this notation, SAR2 and SAR1 are calculated as:

    SAR2=B.sub.2 +D.sub.2

and

    SAR1=B.sub.1 +D.sub.1

Then (SAR2-SAR1)+L becomes:

    (SAR2-SAR1)+L=(B.sub.2 +D.sub.2 -B.sub.1 -D.sub.1)+L

For the current discussion, assume that the calculation of neither SAR2 nor SAR1 wraps. In other words, for 24 bit addressing, a carry is not produced from bit 40 into 39, for 31 bit addressing, no carry is produced from bit 33 into 32; for the 64 bit addressing mode, as has already been discussed, wrapping can not occur. This assumption of no wrapping allows the complication of suppressing the carry into these bit positions to be avoided for the current discussion. This complication will be considered later.

Using two's complement arithmetic, the calculation of (SAR2-SAR1)+L can be expressed as:

    (SAR2-SAR1)+L=(B.sub.2 +D.sub.2 +B.sub.1 +D.sub.1 +1+1)+L

where B₁, and D₁ indicate the one's complement of B₁ and D₁, respectively. The calculation of the results within the parentheses can be reduced to a two-to-one addition as follows: ##EQU27##

The two-to-one addition of G with individual bits g, and H with individual bits h_(i) with H shifted one bit position to the left and the vacancy from the shift filled with a `hot-one` produces B₂ +D₂ -B₁ -D₂.

At this point, the notation used previously needs to be modified to include these latest considerations for determining SAR2-SAR1. Since the two-to-one addition of G and H shifted produces SAR2-SAR1, which was previously denoted as Δ having individual bits δ_(i), the result of the two-to-one addition of G and H shifted will assume this designation. Therefore, ##EQU28##

Similarly, κ_(i) will assume the meaning of the carry from bit i into i-1 for this two-to-one addition. Furthermore, to be consistent with the previous notation, the result of the two-to-one addition of Δ with L will be designated as S whose individual bits will be referred to as S_(i). Thus, ##EQU29##

The carries from bit position i into i-1 for this two-to-one addition will be be designated as c_(i).

The result S, which is SAR2-SAR1+L can also be calculated as a CSA three-to-two addition of G, H shifted, and L producing a sum having the individual bits, σ_(i), and a carry with individual bits, ω_(i), which are added with ω shifted left one bit position before the addition. Though the result of this two-to-one addition produces SAR2-SAR1+L, it will be denoted as Σ having individual bits Σ_(i) to distinguish this calculation from that using two-to-one adders. Therefore, ##EQU30##

The carry from i into i-1 for the two-to-one addition of σ_(i) and ω_(i) shifted will be designated as φ_(i).

By Theorem 6, MVC type overlap exists iff c₅₆ =1 and S_(i) =0 for all 0≦i≦55. Let the prediction that S_(i) =0 for all 0≦i≦55 be designated as S₌₀ while MVC type overlap be designated as O_(MVC). Then

    O.sub.MVC =c.sub.56 S.sub.=0

For O_(MVC) to be a one, c₅₆ must be a one so that S₌₀ needs to be determined only for the case that c₅₆ =1. The determination of S₌₀ when c₅₆ =1 will be designated as S₌₀.sup. . The following theorem provides the basis for determining S₌₀.sup. .

Theorem 7

If c₅₆ =1, then when κ₅₆ =1, φ₅₆ =ω₅₆ =1, and when κ₅₆ =0, either φ₅₆ =1 and ω₅₆ =0 or φ₅₆ =0 and ω₅₆ =1.

Proof:

Since by associativity, the addition of three numbers produces the same result despite the order of addition, then

    S.sub.55 =Σ.sub.55

But

    S.sub.55 =c.sub.56  δ.sub.55  L.sub.55 =c.sub.56  δ.sub.55 0=c.sub.56  δ.sub.55

and

    Σ.sub.55 =ω.sub.56  σ.sub.55  φ.sub.56

so that

    c.sub.56  δ.sub.55 =ω.sub.56  σ.sub.55  φ.sub.56

Recognizing that

    δ.sub.55 =g.sub.55  h.sub.56  κ.sub.56

and

    σ.sub.55 =g.sub.55  h.sub.56  L.sub.55 =g.sub.55  h.sub.56 0=g.sub.55  h.sub.56

results in

    c.sub.56  g.sub.55  h.sub.56  κ.sub.56 =ω.sub.56  g.sub.55 h.sub.56  φ.sub.56

    c.sub.56  κ.sub.56 =ω.sub.56  φ.sub.56

With c₅₆ =1, then

    κ.sub.56 =ω.sub.56  φ.sub.56

If κ₅₆ =0, then

    1=ω.sub.56  φ.sub.56

This identity is met iff ω₅₆ =1 and φ₅₆ =0 or ω₅₆ =0 and φ₅₆₌ 1. Therefore, when κ₅₆ =0, then either ω₅₆ =1 and φ₅₆ =0 or ω₅₆ =0 and φ₅₆ =1.

If κ₅₆ =1, then

    0=ω.sub.56  φ.sub.56

For ω₅₆ and φ₅₆ to comply with this expression, either ω₅₆ =φ₅₆ =1 or ω₅₆ =φ₅₆ =0. It is left to show that ω₅₆ φ₅₆ =1. The expression for κ₅₆ is:

    κ.sub.56 g.sub.56 h.sub.57 +g.sub.56 κ.sub.57 +h.sub.57 κ.sub.57

First, assume that κ₅₇ =0. In this case,

    κ.sub.56 =g.sub.56 h.sub.57

so that for κ₅₆ =1, both g₅₆ =1 and h₅₇ =1. Therefore, ω₅₆ =1 since

    ω.sub.56 =g.sub.56 h.sub.57 +L.sub.56 h.sub.57 +L.sub.56 g.sub.56

Substituting ω₅₆ =1, c₅₆ =1, and κ₅₆ =1 into the relationship of the carries produces:

    1 1=1 φ.sub.56

    0=φ.sub.56

    φ.sub.56 =1

Therefore, when κ₅₇ =0, κ₅₆ =1, and c₅₆ =1, then ω₅₆ =1 and φ₅₆ =1.

Next assume that κ₅₇ 1. Then

    κ.sub.56 =g.sub.56 +h.sub.57

Therefore, for κ₅₆ 1 either g₅₆ =1 or h₅₇ =1. Furthermore,

    c.sub.56 =δ.sub.56 L.sub.56 +δ.sub.56 c.sub.57 +L.sub.56 c.sub.57

Assume that c₅₇ =1. Then

    c.sub.56 =δ.sub.56 +L.sub.56

and since c₅₆ =1, then either δ₅₆ =1 or L₅₆ =1. First assume that L₅₆ =1. Then,

    ω.sub.56 =g.sub.56 +h.sub.57

which since either g₅₆ =1 or h₅₇ =1

    ω.sub.56 =1

Substituting into the relationship for the carries gives:

    1 1=1 φ.sub.56

    0=.sub.56

    φ.sub.56 =1

Now assume that δ₅₆ =1. Since

    δ.sub.56 =g.sub.56  h.sub.57  κ.sub.57

and κ₅₇ has been assumed to be one, then

    δ.sub.56 =g.sub.56  h.sub.57

    1=g.sub.56  h.sub.57

But since either g₅₆ =1 or h₅₇ =1, it follows that both g₅₆ =1 and h₅₇ =1. Therefore, since

    ω.sub.56 =g.sub.56 h.sub.57 +g.sub.56 L.sub.56 +h.sub.57 L.sub.56

it follows that ω₅₆ =1. Substitution into the relationship for the carries produces:

    1 1=1 φ.sub.56

    0=φ.sub.56

    φ.sub.56 =1

Therefore, for κ₅₇ =1, c₅₇ =1, κ₅₆ =1, and c₅₆ =1, then ω₅₆ =1 and φ₅₆ =1. Finally assume that c₅₇ =0. Then,

    c.sub.56 =δ.sub.56 L.sub.56 +δ.sub.56 c.sub.57 +L.sub.56 c.sub.57

    c.sub.56 =δ.sub.56 L.sub.56

so that for c₅₆ =1, then both δ₅₆ =1 and L₅₆ =1. Since,

    ω.sub.56 =g.sub.56 h.sub.57 +g.sub.56 L.sub.56 +h.sub.57 L.sub.56

then

    ω.sub.56 =g.sub.56 +h.sub.57

But for κ₅₇ =1 as assumed, either g₅₆ =1 or h₅₇ =1 from which it follows that ω₅₆ =1. Again substituting into the relationship for the carries produces:

    1 1=1 φ.sub.56

    0=φ.sub.56

    φ.sub.56 =1

Therefore, for κ₅₇ =1, c₅₇ =0, κ₅₆ =1, and c₅₆ =1, then ω₅₆ =1 and φ₅₆ =1 from which it follows that if c₅₆ =1 and κ₅₆ =1 then ω₅₆ =φ₅₆ =1.

QED

Now, consider the calculation of Σ(0:55). Σ is calculated by the two-to-one addition of σ and ω shifted left one bit position. This is represented as: ##EQU31##

It must be determined that all Σ_(i) for 0≦i≦55 are zero when c₅₆ =1. To make this determination. Theorem 7 is used to alter the representation of the calculation of Σ. From theorem 7, when c₅₆ =1, then both φ₅₆ and ω₅₆ must be one when κ₅₆ =1 and only one of φ₅₆ or ω₅₆ can be one when κ₅₆ =0. Therefore, the addition can be represented as the three-to-one addition: ##EQU32##

The advantages of expressing the addition in this fashion result from the theorems to follow. For simplicity of exposition, let σ_(i) be represented by P_(xi) for all 0≦i≦55, and P_(yi), 1≦i≦56 represent ω_(i), 1≦i≦55, concatenated with κ₅₆. The above representation then becomes: ##EQU33## Theorem 8:

If Σ_(i) =0, then the carry at position i, ν_(i), generated by the addition of P_(x), P_(y), and 1 is equal to 1 for all 0≦i≦55.

Proof:

Theorem 8 can be proven by induction.

Base of induction

The expression for the sum at bit position 55 is: ##EQU34##

Assuming that Σ₅₅ =0, then

    P.sub.x55  P.sub.y56 =0,

therefore,

    P.sub.x55  P.sub.y56 =1.

The carry produced at bit position 55, ν₅₅, is:

    ν.sub.55 =P.sub.x55 P.sub.y56 +P.sub.x55 (1)+P.sub.y56 (1)

where + represents logical OR. This reduces to:

    ν.sub.55 =P.sub.x55 +P.sub.y56.

Since if Σ₅₅ =0

    P.sub.x55  P.sub.y56 =1,

and since the EXCLUSIVE-OR is one iff one or the other of P_(x55) or P_(y56) is one, but not both, then:

    P.sub.x55 +P.sub.y56 =1

so that,

    ν.sub.55 =1.

Consequently, the carry from bit 55 into bit 54 is guaranteed to be a one if the sum of the addition at bit 55, Σ₅₅, is equal to zero

Step of induction

Assume that Σ_(i) =0 and ν_(i+1) =1. Since the sum at i, Σ_(i), is

    Σ.sub.i =P.sub.xi  P.sub.yi+1  ν.sub.i+1,

then

    P.sub.xi  P.sub.yi+1  1=0,

or, ##EQU35## The carry at i is:

    ν.sub.i =P.sub.xi P.sub.yi+1 +P.sub.xi ν.sub.i+1 +P.sub.yi+1 ν.sub.i+1.

Since ν_(i+1) =1, then ##EQU36## But from above,

    P.sub.xi  P.sub.yi+1 =1,

from which it follows that

    P.sub.xi +P.sub.yi+1 =1,

and,

    ν.sub.1 =1.

From steps one and two above, it follows by mathematical induction that ν_(i) =1 for 0≦i≦55.

QED

Theorem 9:

The sum, Σ, is zero iff P_(xi) P_(yi+1) =1 for 0≦i≦55.

Proof:

Proof of if

If Σ=0 then from Theorem 8, ν_(i+1) =1 for any i from which it follows that:

    P.sub.xi  P.sub.yi+1 =1.

since Σ_(i) is zero.

Proof of only if

Consider the carry generated at ν_(i). This carry is: ##EQU37##

Since by assumption,

    P.sub.xi  P.sub.yi+1 =1,

then

    ν.sub.i =ν.sub.i+1

Since this must hold for all i and since the carry in is 1, then

    ν.sub.i =ν.sub.i+1 = . . . =1,

Let Σ_(i) =1. But Σ_(i) is:

    Σ.sub.i =P.sub.xi  P.sub.yi+1  ν.sub.i+1.

However,

    P.sub.xi  P.sub.yi+1 =1

from which it follows that:

    ν.sub.i+1 =0.

Therefore, the assumption that Σ_(i) =1 leads to a contradiction and is therefore erroneous. Thus, Σ_(i) must be zero.

QED

The conditions for S₌₀.sup. to be zero follow from Theorems 8 and 9. These conditions are:

    P.sub.xi  P.sub.yi+1 =1

for all 0≦i≦55. Substituting the appropriate values for P_(xi), and P_(yi+1) leads to the expression:

    S.sub.=0.sup. =(σ.sub.0  ω.sub.1)(σ.sub.1  ω.sub.2) . . . (σ.sub.54  ω.sub.55)(σ.sub.55  κ.sub.56)

Once S₌₀.sup. is determined, then as already shown, O_(MVC) can be determined by

    O.sub.MVC =c.sub.56 S.sub.=0.sup.

A limited apparatus for predicting MVC type overlap has just been developed. This apparatus is not general since it was assumed that no wrapping occurred during the calculation of the first and second operand addresses. In addition, it was assumed that the second operand address did not point to the highest 256 byte block when the first operand address points to the lowest 256 byte block of the effective address space. Thus, remapping the first operand address to above the second operand address was not required. To predict of MVC type overlap for the general case, these situations must be considered with corrections made to the previous prediction scheme to predict overlap correctly.

The corrections that must be performed to allow the proper prediction of overlap are shown in Table 3 on page 62. The corrections listed in that table are applicable to all three addressing modes. In the table, REMAP1 occurs when SAR2 resides in the highest 256 byte block and SAR1 resides in the lowest 256 byte block of the address space. When this occurs, SAR1 must be remapped to the 256 byte block immediately above the 256 byte block in which SAR2 resides. This can be accomplished by forcing a one at the bit position adjacent to the left MSB of the bits specifying the address space. This bit position is bit 39 for 24 bit addressing, and bit 32 for 31 bit addressing. Remapping is not required for 64 bit addressing for the reasons discussed previously. WRAP1 and WRAP2 are used to indicate that wrapping occurred during the address calculation of SAR1 and SAR2, respectively, in which the base is added to a displacement. WRAP1 and WRAP2 conditions can be identified by detecting that a carry would be produced out of the MSB of the bits specifying the address space when the base is added With the displacement. Therefore, the carry from bit 40 and 33, must be detected to determine that wrapping has occurred for 24 bit, and 31 bit, respectively. Because the address space for 64 bit addressing in 2⁶⁴ -1 and the MSB of the 64 bit address must be zero, wrapping can not occur when in the 64 bit addressing mode. When wrapping occurs in the 24 or 31 bit addressing modes, however, the carry produced from the MSB of the address space must be suppressed to allow overlap to be predicted correctly.

From the above discussions, the corrections listed in Table 3 on page 62 must be applied only when in 24 and 31 bit addressing modes. The only difference between the corrections required for these two modes is the bit position at which carries are to be suppressed or forced. For this reason, the following discussion describes the application of the corrections for 24 bit addressing only. Results for 31 bit addressing will be presented without development. As stated above, the carry that must be forced or suppressed for 24 bit addressing is the carry that is produced from bit position 40 into bit position 39 during the addition of B and D. This carry can be forced by adding it's value to the addition B+D. The value of the carry is:

    0 0 . . . 0 1 0 . . . 0 0

in which the 1 occurs in bit position 39. Similarly, the carry can be suppressed by adding the two's complement of the carry value. Using the value of the carry from above, the two's complement is: ##EQU38## Therefore, the carry can be suppressed by adding (1 1 . . . 1 1 0 . . . 0 0) to B+D. For predicting MVC type overlap, however, all zeros must be detected for bit positions 0≦i≦55 from the arithmetic operation:

    B.sub.2 +D.sub.2 -(B.sub.1 +D.sub.1)+L

To force the carry due to the address calculation of the first operand, the value of the carry must be added to B₁ +D₁. Since B₁ +D₁ is subtracted in the expression, however, the two's complement of the carry value must be added to the MVC type overlap calculation to force the carry for the first operand address calculation. Similarly, the the carry value must be added to the above expression to suppress the carry from the address calculation for the first operand.

From this discussion, the corrections to be applied for cases one to four of Table 3 on page 62 should be apparent. For the first case, no correction is required. This can be accomplished by adding zero to B₂ +D₂ and to the result of B₁ +D.sub.. The net affect is to add zero to B₂ +D₂ -(B₁ +D₁). For the second case in which wrapping occurs during the calculation of the first operand, the carry that occurs during B₁ +D₁ must be suppressed. Therefore, the value of the carry must be added to B₂ +D₂ -(B₁ +D₁) to suppress this carry for the reasons enumerated above. For case 3, wrapping occurs during the address calculation for the second operand. In this case, the carry due to this address calculation is suppressed by adding the two's complement of the carry value to B₂ +D₂ -(B₁ +D₁). Finally, in the fourth case, wrapping due to the address calculation of both operands must be suppressed. The values that must be added to suppress these carries, however, are additive inverses so that the net result is that a value of zero must be added for this correction. The above results are summarized in the first four rows of Table 4 on page 62.

For the remaining four cases of Table 3 on page 62, remapping of SAR1 immediately above the highest 256 byte block of the address space is required. As previously stated, this is accomplished by forcing a one at appropriate bit positions of the result of the address calculation to produce SAR1. This is identical to forcing a carry into that bit position. Thus, for case 5 in which remapping is required while no wrapping occurs during the calculation of either of the operand addresses, the value of the carry must be added to B₁ +D₁ so that the two's complement of the carry value must be added to B₂ +D₂ -(B₁ +D₁). For case 6, remapping is required while wrapping occurs for the calculation of the first operand. Thus, B₁ +D₁ produces a carry which automatically remaps SAR1 immediately above the highest 256 byte block of the address space. No correction is required which can be accomplished by adding zero to B₂ +D₂ -(B₁ +D₁ ). Cases 7 and 8 cannot occur since the addition of a 12 bit displacement to a 24 bit base cannot wrap and produce an address that resides in the highest 256 byte block of the 24 bit address space. Thus, corresponding entries for these cases are not included in Table 4 on page 62. Identical analyses for 31 bit addressing result in Table 5 on page 63. From tables 4, and 5, it can be seen that five unique corrections arise from consideration of all cases for all addressing modes. These unique corrections are summarized in Table 6 on page 63 with the mapping between the unique corrections and the cases within tables 4 and 5 provided by Table 7 on page 64.

The corrections of Table 6 on page 63 must be applied to the calculation of B₂ +D₂ -(B₁ +D₁) to produce a value for SAR2-SAR1 that is consistent with the assumptions that are contained in theorems three to six. Therefore, the correction values must be applied prior to adding the operand storage length to B₂ +D₂ -(B₁ +D₁). This implies that an additional three-to-two CSA stage is needed to add the correction value and obtain two entities whose addition results in SAR2-SAR1 with wrapping removed and remapping forced as required by those theorems. The output of the CSA can then be treated identically as G and H shifted above to detect overlap.

More parallelism, however, can be obtained as follows. First, B₂ +B₁ +D₁ can be reduced to a sum and a carry by use of a three-to-two adder. If no corrections are to occur, this sum and carry can be added with D₂ by means of a second three-to-two CSA producing G and H shifted for use as described earlier. If corrections are required, however, a two-to-one addition between D₂ and the correction value can be produced immediately since the addition can be accomplished by concatenating the correction value with D₂. For example, correction 3 of Table 6 on page 63, the two-to-one addition of the correction value with D₂ is: ##EQU39## This value can then be added to the sum and carry from the three-to-two addition of B₂ +B₁ -D₁ to generate a corrected G and H which can be treated as in the detection of overlap for the restricted case. Therefore, ##EQU40## To extract maximum parallelism, all the potential corrections given in Table 6 on page 63 can be applied to the calculation of B₂ -B₁ -D₁ +D₂ through a sequence of two three-to-two CSA's to produce all potential G's and H's whose addition produce the desired value for SAR2-SAR1. Each of these are used as shown previously with the appropriate indicator chosen for use once the case has been determined. Determination of the case is made in parallel with these calculations by appropriate decode of the addressing mode, WRAP1, WRAP2, and REMAP1 in accordance with Table 7 on page 64.

                  TABLE 3                                                          ______________________________________                                         Requirements for Forcing or Suppressing Carries                                from MSB of Effective Address Space to Predict                                 MVC Type Operand Overlap                                                       CASE   REMAP1    WRAP2    WRAP1  ACTION                                        ______________________________________                                         CASE 1 NO        NO       NO     No corrective                                                                  action                                        CASE 2 NO        NO       YES    Suppress carry from                                                            MSB for B.sub.1 + D.sub.1                     CASE 3 NO        YES      NO     Suppress carry from                                                            MSB for B.sub.2 + D.sub.2                     CASE 4 NO        YES      YES    Suppress carries                                                               from MSB for B.sub.2 +                                                         D.sub.2 and from B.sub.1 +                                                     D.sub.1                                       CASE 5 YES       NO       NO     Force carry from                                                               MSB for B.sub.1 + D.sub.1                     CASE 6 YES       NO       YES    Allow carry from                                                               MSB for B.sub.1 + D.sub.1                     CASE 7 YES       YES      NO     Impossible                                    CASE 8 YES       YES      YES    Impossible                                    ______________________________________                                    

                                      TABLE 4                                      __________________________________________________________________________     Corrections for MVC Type Overlap Detection for 24 Bit Addressing Mode          CASE  ADD                                                                      __________________________________________________________________________     CASE 1                                                                               000000000000000000000000000000000000000000000000000000000000000          CASE 2                                                                               0000000000000000000000000000000000000001000000000000000000000000         CASE 3                                                                               1111111111111111111111111111111111111111000000000000000000000000         CASE 4                                                                               000000000000000000000000000000000000000000000000000000000000000          CASE 5                                                                               1111111111111111111111111111111111111111000000000000000000000000         CASE 6                                                                               000000000000000000000000000000000000000000000000000000000000000          __________________________________________________________________________

                                      TABLE 5                                      __________________________________________________________________________     Corrections for MVC Type Overlap Detection for 31 Bit Addressing Mode          CASE  ADD                                                                      __________________________________________________________________________     CASE 1                                                                               000000000000000000000000000000000000000000000000000000000000000          CASE 2                                                                               0000000000000000000000000000000010000000000000000000000000000000         CASE 3                                                                               1111111111111111111111111111111110000000000000000000000000000000         CASE 4                                                                               000000000000000000000000000000000000000000000000000000000000000          CASE 5                                                                               1111111111111111111111111111111110000000000000000000000000000000         CASE 6                                                                               000000000000000000000000000000000000000000000000000000000000000          __________________________________________________________________________

                                      TABLE 6                                      __________________________________________________________________________     Unique Corrections Required to Detect MVC Type Overlap                         UNIQUE                                                                         CASES ADD                                                                      __________________________________________________________________________     COR 1 000000000000000000000000000000000000000000000000000000000000000          COR 2 0000000000000000000000000000000000000001000000000000000000000000         COR 3 1111111111111111111111111111111111111111000000000000000000000000         COR 4 0000000000000000000000000000000010000000000000000000000000000000         COR 5 1111111111111111111111111111111110000000000000000000000000000000         __________________________________________________________________________

                  TABLE 7                                                          ______________________________________                                         Mapping Between Unique Corrections for MVC Type Overlap                        Detection and Address Calculation Cases                                        CORRECTION    MAPPING                                                          ______________________________________                                         COR 1         All addressing modes cases 1, 4, and 6                           COR 2         AR 24 Bit Mode case 2                                            COR 3         AR 24 Bit Mode cases 3 and 5                                     COR 4         AR 31 Bit Mode case 2                                            COR 5         AR 31 Bit Mode cases 3 and 5                                     ______________________________________                                    

THE PREFERRED EMBODIMENT

Turning now to our invention in greater detail, it will be seen that FIG. 3 shows an overview of the hardware used to predict MVC type destructive storage operand overlap. Registers Ih, rh, Ia, and ra contain B2, D2, B1, and D1, respectively, which are the base and displacement values for calculating SAR2 and SAR1. These registers feed blocks whose purpose is to predict the wrap conditions, WRAP2 and WRAP1, as well as to determine whether SAR2 is in the high 256 byte block of the address space (SAR2HI) or SAR1 is in the low 256 byte block of the address space (SAR1LO) as shown in FIG. 5 and FIG. 6. SAR2HI and SAR2LO are ANDED, FIG. 3, to produce REMAP1 (not labeled in FIG. 3) that indicates that remapping is required. REMAP1, WRAP2, and WRAP1 are decoded along with the addressing mode according to Table 6 on page 63 to generate COR(1:5) (REMAP1, REMAP2, WRAP1, WRAP2 DECODE block of FIG. 3) that indicate which overlap correction (designated in the equations to follow as O_(MVCCOR1), O_(MVCCOR2), O_(MVCCOR3), O_(MVCCOR4) and O_(MVCCOR5)) should be used to determine overlap. COR(1:5) are fed to the overlap predictor where the actual selection of the appropriate overlap indicator is made. The Overlap Prediction Block implements the algorithms previously discussed. Details of this block are shown in FIG. 4.

In FIG. 4 a carry save adder, CSA 1, is used to execute the three-to-two addition of Ih+Ia₋₋ N+ra₋₋ N(B₂ +B₁ +D₁). The sum, E, and carry, F, produced by CSA 1 are fed to two three-to-two adders, CSA 2 and CSA 3 with F shifted left one bit position and the right most bit position supplied with a `hot one`. In addition to E and F, CSA 2 is fed rh (D₂). The results of CSA 2, therefore, are a sum, G, and a carry, H, who if added with H shifted left one bit position and a `hot one` supplied in the right most position, would produce B₂ +D₂ -(B₁ +D₁). Meanwhile, the left most 40 bit positions of E and F are fed to CSA 3 to be added with 40 one's. This produces values that can be used for correcting the calculation of B₂ +D₂ -(B₁ +D₁) for wrap and remap conditions (ε and δ of FIG. 4 and the equations to following specifying the behavior of the invention). Rather than being added via a two-to-one adder, G and H from CSA 2 are fed to CSA 7 where L is added to the these values to produce a sum, σ, and a carry, ω. In parallel, G(56:63) and H(57:63)∥0 are fed to a carry generator to produce κ₅₆ via standard carry lookahead techniques. Meanwhile, CSA's 4, 5, and 6 add selected combinations of the sum of CSA 2 with the carry from CSA 3 to produce the sum ν and carry N, the sum of CSA 3 with the carry of CSA 2 to produce the sum γ and the carry Γ, and the sum of CSA 3 with its carry to produce the sum τ and the carry T, respectively, that are required for correcting for wrap and remap conditions.

Various combinations of the sums, ν, γ, τ, and σ and the carries, N, Γ, T and ω, produced by CSA 4, 5, 6, and 7 along with κ₅₆ are EXCLUSIVE-ORed in preparation of generating S₌₀.sup. for the various correction cases. In parallel, σ(56:63) and ω(57:63)∥0 are fed to a carry generator to produce φ₅₆ from which c₅₆ can be generated by its combination with κ₅₆, and ω₅₆ according to

    c.sub.56 =(ω.sub.56  κ.sub.56) φ.sub.56

This calculation is preformed by a series of 2-way EXCLUSIVE-OR'S as can be seen from FIG. 4. Appropriate outputs of all the EXCLUSIVE-OR's are then fed to 57W-AND's to produce MVC type overlap, O_(MVC), for the six cases summarized in Table 6 on page 63. The appropriate value is selected by COR(1:5), produced by the decoder shown in FIG. 3, to generate the correct MVC type overlap condition designated as OVERLAP in FIG. 4. OVERLAP is then fed to a branch low multiplexer (not shown in FIG. 4) for presentation to the control store next addressing logic for choosing one of two microinstructions for execution on the subsequent cycle. OVERLAP is also latched to make this condition available to subsequent microinstructions later in the instruction cycle. This latch is reset by NEWID bit to be taken from the EIR register, NEWID₋₋ EIR, that is setup by the control store logic. The timing for this NEWID signal is: ##STR1## NEWID can not become valid at the end of the microcoded exception handler if an exception causes the microcoded exception handler to be invoked in the middle of a microcoded routine. The OVERLAP latch is held if NOT₋₋ NEWID₋₋ EIR or PIPELINE₋₋ HOLD are active; otherwise, a new value is latched. The latching of all overlap BR LO conditions is performed in Control Store. The reader is referred to that workbook for details. The unlatched versions of the overlap conditions are shown in the logic diagrams.

The determination of OVERLAP is fully specified by the following equations. These equations use the following notation

    ______________________________________                                         lh.sub.i                                                                           The ith bit of the LH register that contains B.sub.2                       la.sub.i                                                                           The ith bit of the LA register that contains B.sub.1                       rh.sub.i                                                                           The ith bit of the RH register that contains D.sub.2 This is assumed           to be a 12 bit register and is so numbered. AGEN occurs by                     concatenating 56 zero's on the left before using this register                 as an addend.                                                              ra.sub.i                                                                           The ith bit of the RA register that contains D.sub.1 This is assumed           to be a 12 bit register and is so numbered. AGEN occurs by                     concatenating 56 zero's on the left before using this register                 as an addend.                                                              ______________________________________                                    

The equations are:

    __________________________________________________________________________     CSA1                                                                           e.sub.i = lh.sub.i  la.sub.i                            0≦i≦                                                             51                     e.sub.i = lh.sub.i  la.sub.i  ra.sub.(i-52)             52≦i.ltoreq                                                             .63                    f.sub.i = lh.sub.i + la.sub.i  = lh.sub.i  la.sub.i     1≦i≦                                                             51                     f.sub.i = lh.sub.i la.sub.i + lh.sub.i ra.sub.(i-52) + la.sub.i  ra.sub.(i     -52)                                                    52≦i.ltoreq                                                             .63                    CSA2                                                                           g.sub.i = e.sub.i  f.sub.i+1                            0≦i≦                                                             51                     g.sub.i = e.sub.i  f.sub.i+1  rh.sub.(i-52)             52≦i.ltoreq                                                             .62                    g.sub.63 = e.sub.63  rh.sub.(11)                                               h.sub.i = e.sub.i f.sub.i+1                             1≦i≦                                                             51                     h.sub.i = e.sub.i f.sub.i+1 + e.sub.i rh.sub.(i-52) + f.sub.i+1 rh.sub.(i-     52)                                                     52≦i.ltoreq                                                             .62                    h.sub.63 = e.sub.63 + rh.sub.(11)                                              CSA3                                                                           δ.sub.i  = g.sub.i                                0≦i≦                                                             39                     ε.sub.-- n.sub.i = e.sub.i + f.sub.i+1          123 i≦39        CSA7                                                                           σ.sub.i = g.sub.i  h.sub.i+1                      0≦i≦                                                             55                     σ.sub.i = g.sub.i  h.sub.i+1  l.sub.(i-56)        56≦i.ltoreq                                                             .62                    σ.sub.63 = g.sub.63  l.sub.7                                             ω.sub.i = g.sub.i h.sub.i+1                       1≦i≦                                                             55                     ω.sub.i = g.sub.i h.sub.i+1 + g.sub.i l.sub.(i-56) + h.sub.i+1           l.sub.(i-56)                                            56≦i.ltoreq                                                             .62                    ω.sub.63 = g.sub.63 + l.sub.7                                            CSA6                                                                           τ.sub.i = g.sub.i  ε.sub.-- n.sub.i+1       0≦i≦                                                             38                     T.sub.i = g.sub.i + ε--n.sub.i+1                1≦i≦                                                             38                     CSA5                                                                           γ.sub.i = g.sub.i  h.sub.i+1                      i = 32, 39             Γ.sub.i  = g.sub.i + h.sub.i+1                    i = 32, 39             CSA4                                                                           ?.sub.i = g.sub.i  ε.sub.-- n.sub.i+1           i = 31, 38             N.sub.i = g.sub.i + ε.sub.-- n.sub.i+1          i = 31, 38             CLA1                                                                           (κH).sub.i = g.sub.i  h.sub.i+1                   56≦i.ltoreq                                                             .63                    (κG).sub.i-- N = g.sub.i h.sub.i+1                56≦i.ltoreq                                                             .62                    (κT).sub.i-- N = g.sub.i + h.sub.i+1              56≦i.ltoreq                                                             .62                    (κC).sub.63-- N = g.sub.63                                               (κG).sub.i.sup.i +1 = (κG).sub.i-- N((κT).sub.i-- N +        (κG).sub.i+1-- N)                                 56≦i.ltoreq                                                             .61                    (κT).sub.i.sup.i+1 = (κT).sub.i-- N + (κT).sub.i                                                                     56≦i.ltoreq                                                             .61                    (κC).sub.62 = (κG).sub.62-- N((κT).sub.62-- N +              (κC).sub.63-- N)                                                         (κC).sub.63 = (κC).sub.63-- N                                      (κG).sub.i.sup.i+3.sub.-- N = (κG).sub.1.sup.i+1                   + (κT).sub.1.sup.i+1 (κG).sub.1+2.sup.i+3   56≦i.ltoreq                                                             .59                    (κT).sub.i.sup.i+3.sub.-- N = (κT).sub.1.sup.i+1 (κT).su     b.1+2.sup.1+3                                           56≦i.ltoreq                                                             .59                    (κC).sub.i-- N = (κG).sub.1.sup.i+1 + (κT).sub.1.sup.i+1      (κC).sub.i+2                                     i = 60, 61             (κC).sub.i-- N = (κC).sub.i                 i = 62, 63             κ.sub.i = (κG).sub.1.sup.i+3.sub.-- N ((κT).sub.1.sup.1+     3.sub.-- N + (κC).sub.i+4-- N)                    57≦i.ltoreq                                                             .59                    (κC).sub.i = (κC).sub.i-- N                 60≦i.ltoreq                                                             .63                    κ.sub.56 = (κG).sub.56.sup.59.sub.13 N ((κT).sub.56.sup.     59.sub.-- N + (κC).sub.60-- N)                                           S.sub.i = (κ C).sub.i+1  (κH).sub.i         57≦i.ltoreq                                                             .63                    S.sub.56 = κ.sub.57  (κH).sub.56                                   S.sub.63-- N = S.sub.63                                                        CG1                                                                            (φG).sub.i-- N = φ.sub.iω.sub.i+1         56≦i.ltoreq                                                             .62                    (φT).sub.i-- N = φ.sub.i + ω.sub.i+1      56≦i.ltoreq                                                             .62                    (φC).sub.63-- N = φ.sub.63 ω.sub.64                              (φG).sub.i.sup.i+1 = (φG).sub.i-- N ((φT).sub.i-- N +              (φG).sub.i+1-- N)                                   i = 56, 58, 60         (φT).sub.i.sup.i+1 = (φT).sub.i-- N + (φT).sub.i+1-- N             (φC).sub.62 = (φG).sub.62-- N ((φT).sub.62-- N                     + (φC).sub.63-- N)                                                         (φG).sub.56.sup.59.sub.-- N = (φG).sub.56.sup.57                       + (φT).sub.56.sup.57 (φG).sub.58.sup.59                                (φT).sub.56.sup.59.sub.-- N = (φ T).sub.56.sup.57                      (φT).sub.58.sup.59                                                         (φC).sub.60-- N = (φG).sub.60.sup.61 + (φT).sub.60.sup.61          (φC).sub.62                                                                φ.sub.56 = (φG).sub.56.sup.59 .sub.--N((φT).sub.56.sup.59.sub.     -- N + (φC).sub.60-- N)                                                    XR7 and XR8                                                                    C.sub.56 = κ.sub.56  .sub.ω.sub.56  φ.sub.56                   A5                                                                             S.sub.=.sup. .sub.0COR1 = (σ.sub.0  ω.sub.1) (σ.sub.1        ω.sub.2) . . . (σ.sub.54  ω.sub.55) (σ.sub.55          κ.sub.56)                                                                O.sub.MVCCOR1 = S.sub.=.sup. .sub.0COR1 C.sub.56                               A3                                                                             S.sub.=.sup. .sub.0COR2 = σ.sub.0  ω.sub.1) (σ.sub.1         ω.sub.2) . . . (σ.sub.35  ω.sub.36) (σ.sub.36          .sub.ω.sub.37) (φ.sub.37  N.sub.38) (ν.sub.36  Γ.sub.39     ) (γ .sub.39  ω.sub.40) (φ.sub.40  ω.sub.40)             (σ.sub.40  ω.sub.41)                                               (σ.sub.41  ω.sub.42) . . . (σ.sub.54  ω.sub.55)        (σ.sub.55  κ.sub.56)                                               O.sub.MYCCOR2 = S.sub.= t.sub.0COR2 C.sub.56                                   A4                                                                             S.sub.=.sup. .sub.0COR3 = (τ.sub.0  T.sub.1) (τ.sub.1  T.sub.2) .      . . (τ.sub.36  T.sub.37) (τ.sub.37  T.sub.38) (τ.sub.38            Γ.sub.39) (γ.sub.39  ω.sub.40) (φ.sub.40  ω.su     b.41) (σ.sub.41  ω.sub.42) . . .                                   (σ.sub.54  ω.sub.55) (σ.sub.55  κ.sub.56)              O.sub.MYCCOR3 = S.sub.=.sup. .sub.0COR3 C.sub.56                               A1                                                                             S.sub.=.sup. .sub.0COR4 = (σ.sub.0  ω.sub.1) (σ.sub.1        ω.sub.2) . . . (σ.sub.28  ω.sub.29) (σ.sub.29          ω.sub.30) (σ.sub.30  N.sub.31) (ν.sub.31  Γ.sub.32)       (γ.sub.32  ω.sub.33) (σ.sub.33  ω.sub.34)              (σ.sub.34  ω.sub.35) . . . (σ.sub.54  ω.sub.55)        (σ.sub.55  κ.sub.56)                                               O.sub.MVCCOR4 = S.sub.=.sup. .sub.0COR4 C.sub.56                               A2                                                                             S.sub.=.sup. .sub.0COR5 = (τ.sub.0  T.sub.2) . . . (τ.sub.29           T.sub.30) (τ.sub.30  T.sub.31) ( τ.sub.31  Γ.sub.32) (           γ.sub.32  ω.sub.33) ( σ.sub.33  ω.sub.34)              (σ.sub.34  ω.sub.35) . . .                                         (σ.sub.54  ω.sub.55) (σ.sub.55  κ.sub.56)              O.sub.MYCCOR5 = S.sub.=.sup. .sub.0COR5 C.sub.56                               SAR1HI Detect 12 Bit Add                                                       SAR1H.sub.i = la.sub.i  ra.sub.(i-52)                   52≦i.ltoreq                                                             .55                    SAR1G.sub.i-- N = la.sub.i ra.sub.(i-52)                52≦i.ltoreq                                                             .62                    SAR1T.sub.i-- N = la.sub.i + ra.sub.(i-52)              52≦i.ltoreq                                                             .62                    SAR1C.sub.63-- N1 = la.sub.63 ra.sub.11                                        SAR1H.sub.i-- N = SAR1H.sub.i                           52≦i.ltoreq                                                             .55                    (SAR1G).sub.i.sup.i+1 = (SAR1G).sub.i-- N ((SAR1T).sub.i-- N                   + (SAR1G).sub.i+1-- N)                                  52≦i.ltoreq                                                             .61                    (SAR1T).sub.i.sup.i+1 = ((SAR1T).sub.i-- N + (SAR1T).sub.i+1-- N)                                                                      52≦i.ltoreq                                                             .61                    (SAR1C1).sub.62 = (SAR1G).sub.62-- N ((SAR1T).sub.62-- N                       + (SAR1C).sub.63-- N1)                                                         (SAR1C1).sub.63 = (SAR1C).sub.63-- N1                                          (SAR1G).sub.i.sup.i+3.sub.-- N = (SAR1G).sub.i.sup.i+1 + (SAR1T).sub.i.sup     .i+1 (SAR1G).sub.i+2.sup.i+3                            52≦i.ltoreq                                                             .59                    (SAR1T).sub.i.sup.i+3.sub.-- N = (SAR1T).sub.i.sup.i+1 (SAR1T).sub.i+2.sup     .i+3                                                    52≦i.ltoreq                                                             .59                    (SAR1C).sub.i-- N2 = (SAR1G).sub.i.sup.i+1 + (SAR1T).sub.i.sup.i+1             (SAR1C1).sub.i+2                                        i = 60, 61             (SAR1C).sub.i-- N2 = (SAR1C1).sub.1                     i = 62, 63             (SAR1G).sub.i.sup.i+7 = (SAR1G).sub.i.sup.i+3.sub.-- N((SAR1T).sub.i.sup.i     +3.sub.-- N + (SAR1G).sub.i+4.sup.i+7.sub.-- N)         52≦i.ltoreq                                                             .55                    (SAR1T).sub.i.sup.i+7 = (SAR1T).sub.i.sup.i+3.sub.-- N + (SAR1T).sub.i+4.s     up.i+7.sub.-- N                                         52≦i.ltoreq                                                             .55                    (SAR1C).sub.56 = (SAR1G).sub.56.sup.59 N ((SAR1T).sub.56.sup.59.sub.-- N       + (SAR1C).sub.60-- N2)                                  56                     (SAR1C).sub.i = (SAR1C).sub.i-- N2                      60≦i.ltoreq                                                             .63                    (SAR1C).sub.i-- N = (SAR1G).sub.i.sup.i+7 + (SAR1T).sub.i.sup.i+7              (SAR1C).sub.i+8                                         52≦i.ltoreq                                                             .55                    (SAR1C).sub.56-- N = (SAR1C).sub.56                                            (SAR1.sub.i-- N = (SAR1C).sub.i+1-- N SAR1H.sub.i       52≦i.ltoreq                                                             .55                    SAR1.sub.i = (SAR1C).sub.i+1-- NASAR1H.sub.i.sub.-- N   52≦i.ltoreq                                                             .55                    SAR1.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ZEROS = (SAR1.sub.52.sub.-- N)       (SAR1.sub.53-- N) (SAR1.sub.55.sub.-- N)                                       SAR1.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ONES = (SAR1.sub.52)                 (SAR1.sub.53) (SAR1.sub.54) (SAR1.sub.55)                                      (SAR1C).sub.52 = (SAR1C).sub.52-- N                                            SAR1HI, SAR1LO, WRAP1 Detection Logic                                          la.sub.i-- N = la.sub.i                                 33≦i.ltoreq                                                             .51                    la.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ZEROS = la.sub.40.sub.-- N             la.sub.41.sub.-- N . . . la.sub.50.sub.-- N la.sub.51.sub.-- N                 la.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES la.sub.50                         la.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ONES = la.sub.-- 40.sub.--             TO.sub.-- 50.sub.-- ONES la.sub.51                                             la.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES = la.sub.40-- TO.sub.--           50.sub.-- ONES la.sub.51.sub.-- N                                              la.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ZEROS = la.sub.33-- N la.sub.34--      N . . . la.sub.38--N la.sub.39--N                                              la.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ONES = la.sub.33 la.sub.34 . . .       la.sub.38 la.sub.39                                                            la.sub.-- 33.sub.-- TO.sub.-- 50.sub.-- ONES.sub.-- A.sub.-- 51.sub.--         ZERO = la.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ONES la.sub.-- 40.sub.--        TO.sub.-- 50.sub.-- ONES.sub.-- A.sub.-- 51.sub.-- ZERO                        la.sub.-- 33.sub.-- 51.sub.-- ZEROS = la.sub.-- 33.sub.-- TO.sub.--            39.sub.-- ZEROS la.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ZEROS                  la.sub.-- 33.sub.-- TO.sub.-- 51.sub.-- ONES = la.sub.-- 33.sub.--             TO.sub.-- 39.sub.-- ONES la.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ONES          SAR1.sub.-- TO.sub.-- 51.sub.-- 0S = 24.sub.-- BIT.sub.-- MD la.sub.--         40.sub.-- TO.sub.-- 51.sub.-- ZEROS + 31.sub.-- BIT.sub.-- MD la.sub.--        33.sub.-- TO.sub.-- 51.sub.-- ZEROS                                            SAR1.sub.-- TO.sub.-- 51.sub.-- 1S = 24.sub.-- BIT.sub.-- MD la.sub.--         40.sub.-- TO.sub.-- 51.sub.-- ONES + 31.sub.-- BIT.sub.-- MD la.sub.--         33.sub.-- TO.sub.-- 51.sub.-- ONES                                             SAR1.sub.-- TO.sub.-- 1S.sub.-- A.sub.-- 51.sub.-- 0 = 24.sub.-- BIT.sub.-     - MD la.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- OMES.sub.-- A.sub.--              51.sub.-- ZERO +                                                               31.sub.-- BIT.sub.-- MD la.sub.-- 33.sub.-- TO.sub.-- 50.sub.-- ONES.sub.-     - A.sub.-- 51.sub.-- ZERO                                                      SAR1LO = [(SAR1C).sub.52-- N SAR1.sub.-- TO.sub.-- 51.sub.-- 0S +              (SAR1C).sub.52 SAR1.sub.-- TO.sub.-- 51.sub.-- aS] SAR1.sub.-- 52.sub.--       TO.sub.-- 55.sub.-- ZEROS                                                      SAR1HI = [(SAR1C).sub.52-- N SAR1.sub.-- TO.sub.-- 51.sub.-- 1S +              (SAR1C).sub.52 SAR1.sub.-- TO.sub.-- 50.sub.-- 1S.sub.-- A.sub.--              51.sub.-- 0] SAR1.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ONES                    WRAP1 = )SAR1C).sub.52 SAR1.sub.-- TO.sub.-- 51.sub.-- 1S                      WRAP1.sub.-- N = WRAP1                                                         SAR2HI Detect 12 Bit Add                                                       SAR2H.sub.i = lh.sub.i  rh.sub.(i-52)                   52≦i.ltoreq                                                             .55                    SAR2G.sub.i-- N = lh.sub.i rh.sub.(i-52)                52≦i.ltoreq                                                             .62                    SAR2T.sub.i-- N = lh.sub.i + rh.sub.(i-52)              52≦i.ltoreq                                                             .62                    SAR2C.sub.63-- N1 = lh.sub.63 rh.sub.11                                        SAR2H.sub.i-- N = SAR2H.sub.i                           52≦i.ltoreq                                                             .55                    (SAR2G).sub.i.sup.i+1 = (SAR2G).sub.i-- N ((SAR2T).sub. i-- N                  + (SAR2G).sub.i+1-- N)                                  52≦i.ltoreq                                                             .61                    (SAR2T).sub.i.sup.i+1 = ((SAR2T).sub.i-- N + (SAR2T).sub.i+1-- N)                                                                      52≦i.ltoreq                                                             .61                    (SAR2C1).sub.62 = (SAR2G).sub.62-- N ((SAR2T).sub.62-- N                       + (SAR2C).sub.63-- N1)                                                         (SAR2C1).sub.63 = (SAR2C).sub.63-- N1                                          (SAR2G).sub.i.sup.i+3.sub.-- N = (SAR2G).sub.i.sup.i+1 + (SAR2T).sub.i.sup     .i+1 (SAR2G).sub.i+2.sup.i+3                            52≦i.ltoreq                                                             .59                    (SAR2T).sub.i.sup.i+3.sub.-- N = (SAR2T).sub.i.sup.i+1 (SAR2T).sub.i+2.sup     .i+3                                                    52≦i.ltoreq                                                             .59                    (SAR2C).sub.i-- N2 = (SAR2G).sub.i.sup.i+1 + (SAR2T).sub.i.sup.i+1             (SAR2C1).sub.i+2                                        i = 60, 61             (SAR2C).sub.i-- N2 = (SAR2C1).sub.i                     i = 62, 63             (SAR2G).sub.i.sup.i+7 = (SAR2G).sub.i.sup.i+3.sub.-- N ((SAR2T).sub.i.sup.     i+3.sub.-- N + (SAR2G).sub.i+4.sup.i+7.sub.-- N)        52≦i.ltoreq                                                             .55                    (SAR2T).sub.i.sup.i+7 = (SAR2T).sub. i.sup.i+3.sub.-- N                        + (SAR2T).sub.i+4.sup.i+7.sub.-- N                      52≦i.ltoreq                                                             .55                    (SAR2C).sub.56 = (SAR2G).sub.56.sup.59.sub.-- N ((SAR2T).sub.56.sup.59.sub     .-- N + (SAR2C).sub.60-- N2)                            56                     (SAR2C).sub.i = (SAR2C).sub.i-- N2                      60≦i.ltoreq                                                             .63                    (SAR2C).sub.i-- N = (SAR2G).sub.i.sup.i+7 + (SAR2T).sub.i.sup.i+7              (SAR2C).sub.i+8                                         52≦i.ltoreq                                                             .55                    (SAR2C).sub.56-- N = (SAR2C).sub.56                                            SAR2.sub.i-- N = (SAR2C).sub.i+1-- NASAR2H.sub.i        52≦i.ltoreq                                                             .55                    SAR2.sub.i = (SAR2C)i+1--NASAR2H.sub.i-- N              52≦i.ltoreq                                                             .55                    SAR2.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ZEROS = (SAR2.sub.52-- N)            (SAR2.sub.53-- N) (SAR2.sub.54-- N) (SAR2.sub.55--N)                           SAR2.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ONES = (SAR2.sub.52)                 (SAR2.sub.53) (SAR2.sub.54) (SAR2.sub.55)                                      (SAR2C).sub.52 = (SAR2C).sub.52-- N                                            SAR2HI, SAR2LO, WRAP2 Detection Logic                                          lh.sub.i-- N =  lh.sub.i                                33≦i.ltoreq                                                             .51                    lh.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ZEROS = lh.sub.40.sub.-- N             lh.sub.41.sub.-- N . . . oh.sub.50.sub.-- N lh.sub.51.sub.-- N                 lh.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES = lh.sub.40 lh.sub.41 . . .       lh.sub.50                                                                      lh.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ONES = lh.sub.-- 40.sub.--             TO.sub.-- 50.sub.-- ONES lh.sub.51                                             lh.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES.sub.-- A.sub.-- 51.sub.--         ZERO = lh.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES lh.sub.51.sub.-- N         lh.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ZEROS = lh.sub.33.sub.-- N             lh.sub.34.sub.-- N . . . lh.sub.38.sub.-- N lh.sub.39.sub.-- N                 lh.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ONES = lh.sub.33 lh.sub.34 . . .       lh.sub.38 lh.sub.39                                                            lh.sub.-- 33.sub.-- TO.sub.-- 50.sub.-- ONES.sub.-- A.sub.-- 51.sub.--         ZERO = lh.sub.-- 33.sub.-- TO.sub.-- 39.sub.-- ONES lh.sub.-- 40.sub.--        TO.sub.-- 50.sub.-- ONES.sub.-- A.sub.-- 51.sub.-- ZERO                        lh.sub.-- 33.sub.-- TO.sub.-- 51.sub.-- ZEROS = lh.sub.-- 33.sub.--            TO.sub.-- 39.sub.-- ZEROS lh.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ZEROS        lh.sub.-- 33.sub.-- TO.sub.-- 51.sub.-- ONES = lh.sub.-- 33.sub.--             TO.sub.-- 39.sub.-- ONES lh.sub.-- 40.sub.-- TO.sub.-- 51.sub.-- ONES          SAR2.sub.-- TO.sub.-- 51.sub.-- 0S = 24.sub.-- BIT.sub.-- MD lh.sub.--         40.sub.-- TO.sub.-- 51.sub.-- ZEROS + 31.sub.-- BIT.sub.-- MD lh.sub.--        33.sub.-- TO.sub.-- 51.sub.-- ZEROS                                            SAR2.sub.-- TO.sub.-- 51.sub.-- 1S = 24.sub.-- BIT.sub.-- MD lh.sub.--         40.sub.-- TO.sub.-- 51.sub.-- ONES + 31.sub.-- BIT.sub.-- MD lh.sub.--         33.sub.-- TO.sub.' 51.sub.-- ONES                                              SAR2.sub.-- TO.sub.-- 50.sub.-- 1Shd --A.sub.-- 51.sub.-- 0 = 24.sub.--l       BIT.sub.-- MD lh.sub.-- 40.sub.-- TO.sub.-- 50.sub.-- ONES.sub.--              A.sub.-- 51.sub.-- ZERO +                                                      31.sub.-- BIT.sub.-- MD lh.sub.-- 33.sub.-- TO.sub.-- 50.sub.-- ONES.sub.-     - A.sub.-- 51.sub.-- ZERO                                                      SAR2LO = [(SAR2C).sub.52-- N SAR2.sub.-- TO.sub.-- 51.sub.-- 0S +              (SAR2C).sub.52 SAR2.sub.-- TO.sub.-- 51.sub.-- 1S]SAR2.sub.-- 52.sub.--        TO.sub.-- 55.sub.-- ZEROS                                                      SAR2HI = [(SAR2C).sub.52-- N SAR2.sub.-- TO.sub.-- 51.sub.-- 1S +              (SAR2C).sub.52 SAR2.sub.-- TO.sub.-- 50.sub.-- 1S.sub.-- A.sub.--              51.sub.-- 0]SAR2.sub.-- 52.sub.-- to.sub.-- 55.sub.-- ONES                     WRAP2 = (SAR2C).sub.52 SAR2.sub.-- TO.sub.-- 51.sub.-- 1S                      WRAP2.sub.-- N = WRAP2                                                         COR(1:5) Generation Logic                                                      REMAP1.sub.-- N = SAR2HI SAR2LO                                                REMAP2.sub.-- N = SAR2LO SAR1HI                                                REMAP1 = REMAP1.sub.-- N                                                       REMAP2 = REMAP2.sub.-- N                                                       COR(1) = 64.sub.-- BIT.sub.-- MD + REMAP1.sub.-- N WRAP1.sub.-- N              WRAP2.sub.-- N + WRAP2 WRAP1                                                   COR(2) = 24.sub.-- BIT.sub.-- MD REMAP1.sub.-- N WRAP2.sub.-- N WRAP1          COR(3) = 24.sub.-- BIT.sub.-- MD WRAP2 WRAP1.sub.-- N + 24.sub.--              BIT.sub.-- MD REMAP1 WRAP1.sub.-- N                                            COR(4) = 31.sub.-- BIT.sub.-- MD REMAP1.sub.-- N WRAP2.sub.-- N WRAP1          COR(5) = 31.sub.-- BIT.sub.-- MD WRAP2 WRAP1.sub.-- N + 31.sub.--              BIT.sub.-- MD REMAP1 WRAP1.sub.-- N                                            OVERLAP Generation Logic                                                       OVERLAP = COR(1) O.sub.MVCCOR1 + COR(2) O.sub.MVCCOR2 + COR(3)                 O.sub.MVCCOR3 + COR(4) O.sub.MVCCOR4 +                                         COR(5) O.sub.MVCCOR5                                                           __________________________________________________________________________

While we have described our preferred embodiments of our invention, it will be understood that those skilled in the art, both now and in the future, may make make various improvements and enhancements which fall within the scope of the claims which follow. These claims should be construed to maintain the proper protection for the invention first disclosed. 

What is claimed is:
 1. A system to predict destructive overlap between a first operand and a second operand stored in a memory, said first operand including a first base address and a displacement from the first base address and said second storage operand including a second base address and a displacement from the second base address, comprising in combination:first means responsive to said first base address and to said displacement from the first base address to detect a wrap condition of said first operand in said memory and to detect the presence of said first operand in a high block of said memory; second means responsive to said second base address and to said displacement from the second base address to detect a wrap condition of said second operand in said memory and to detect the presence of said second operand in a low block of said memory; means responsive to said first means and said second means to generate an overlap correction factor in predicting a destructive overlap between said first operand and said second operand; a storage operand overlap predictor responsive to said first base address, said displacement from said first base address, said second base address, said displacement from said second base address, and said overlap correction factor to generate an output indicative of a destructive overlap between said first operand and said second operand.
 2. A system to predict destructive overlap as in claim 1 wherein said first means is a source storage operand address high and wrap detector and said second means is a destination storage operand address low and wrap detector.
 3. The system to predict destructive overlap of claim 2 wherein overlap is predicted from inputs used for generating a destination storage operand address and a source storage operand address along with an operand length and performed in parallel with a calculation of the source and destination storage operand addresses.
 4. The system to predict destructive overlap of claim 2 wherein in the destination storage operand address low and wrap detector it is determined that a destination operand address lies in a low 256 byte block of a virtual address and whether wrapping from a high 4K block of the virtual address to a low 4K block of the virtual address space occurs during address generation.
 5. The system to predict destructive overlap of claim 2 wherein in the destination storage operand address low and wrap detector a 64 bit input, Ia, is supplied the first base address while a 12 bit input, ra, is supplied the displacement used for calculating a destination storage operand address.
 6. The system to predict destructive overlap of claim 2 wherein in the source storage operand high and wrap detector it is determined that a source operand address lies in a high 256 byte block of a virtual address space and whether wrapping from a high 4K block of the virtual address space to the low 4K block of the virtual address space occurs during address generation.
 7. The system to predict destructive overlap of claim 2 wherein the source stage operand high and wrap detector includes a 64 bit input, Ih, supplied a base while a 12 bit input, rh, is supplied a displacement used for calculating a destination storage operand address. 